Le script suivant permet de retrouver les dates de sauvegarde et restauration des BD du serveur ms SQL Server courant.
requete oracle :Table/Champ
Sur une bd Oracle
- Recherche d’un champ à partir d’un motif
Select TABLE_NAME, COLUMN_NAME from USER_TAB_COLUMNS where COLUMN_NAME like '%'
- Recherche d’une table à partir d’un motif
SELECT * FROM user_tables where table_name like '%'
Sur Sql Server
select TB.name [table], C.name [champ], T.name [type], from sysobjects as TB join syscolumns as C on TB.id=C.id join systypes as T on C.xtype=T.xtype where TB.xtype='U' and T.name like '%' order by TB.name, C.name
démarrer avec django
Sauvegarde site perso free.fr
XML (fichier de conf)
La classe définie dans le script ci dessous est un outil de lecture écriture de config dans un fichier xml. Continuer la lecture de « XML (fichier de conf) »
Recherche multifichier d’un motif
Recherche d’un motif (expression régulière) dans les fichiers de l’arborescence d’un dossier. Continuer la lecture de « Recherche multifichier d’un motif »
python: variation BD Oracle
Le script ci dessous produit une classe sign qui permet de calculer une clef de chaque table de’une bd Oracle. Continuer la lecture de « python: variation BD Oracle »
variation BD SQL Server
variation BD SQL Server
Le code ci dessus créer la classe sign qui permet de générer les clefs checksum de tous les objets (table,procédures stockée fonction et vues) d’une base de données SQL server.
Usage:
| méthode |
description |
| sign() | créer une instance de la classe |
| connect() | se connecte au serveur de données (ms SQL server) |
| checksum() | calcul la clef de chaque objet de la bd |
| checksumTables() | calcule la clef de toutes les tables de la bd |
| checksumScripts() | calcule la clef de touts les script procédures fonctions vues |
| save() | enregistre le résultat du calcul dans un fichier |
#-*-coding:utf-8-*-
"""
Objet
Calcul des clefs checksum de chaque objet d'une base SQL
Tables/Procédures/fonctions/vues
"""
import pymssql
import Tkinter, tkFileDialog # pour save
import time
import datetime
class sign(dict):
def __init__(self):
pass
def connect(self,srv,db,usr=None,pwd=None):
"""connexion à un serveur ms sql server"""
self.server=srv
self.database=db
if usr:
self.cnx= pymssql.connect(host=srv,user=usr,password=pwd,database=db)
else:
self.cnx= pymssql.connect(host=srv,user=usr,trusted=True)
def scripts(self):
"""retrourne la liste des nom de fonctions, vue, et procedures de la bd"""
rq = "select name from sysobjects where xtype in ('P','V','IF','TF','FN')"
crs=self.cnx.cursor()
crs.execute(rq)
ds=crs.fetchall()
crs.close()
T=[]
for dr in ds:
T.append(dr[0])
return T
def tables(self):
"""liste des tables """
rq="select name from sysobjects where xtype in ('U')"
crs=self.cnx.cursor()
crs.execute(rq)
ds=crs.fetchall()
crs.close()
T=[]
for dr in ds:
T.append(dr[0])
return T
def checksumScript(self,scriptName):
""" Objet calcul la clef du script passé en param """
self.sqlexec("create table #script(texte varchar(255))")
self.sqlexec("insert into #script exec ('sp_helptext ''%s''')" % scriptName)
R=self.checksumTable("#script")
self.sqlexec("drop table #script")
return R
def checksumTable(self,tableName):
""" Objet calcul la clef de la table passée en param """
rq="select checksum_agg(binary_checksum(*)) from %s" % tableName
R= self.sqlGetValue(rq)
if not R:
R=0
return R
def sqlGetValue(self, requete):
"""retourne une valeur scalaire d'une requete sql"""
crs=self.cnx.cursor()
crs.execute(requete)
dr=crs.fetchone()
R=dr[0]
crs.close()
return R
def sqlGetValues(self, requete):
"""retourne la premiere colonne d'un jeu de donnée sous form de liste"""
crs=self.cnx.cursor()
crs.execute(requete)
ds=crs.fetchall()
crs.close()
T=[]
for dr in ds:
T.append(dr[0])
return T
def sqlexec(self,requete):
"""execute l'instruction sql passée en param"""
crs=self.cnx.cursor()
crs.execute(requete)
crs.close()
def checksumTables(self):
"""calcul la clef de toutes les tables de la bd"""
self.type='tables'
self.clear()
for t in self.tables():
self[t]=self.checksumTable(t)
def checksumScripts(self):
"""calcul la clef de tous les scripts de la bd"""
self.type='scripts'
self.clear()
for s in self.scripts():
self[s]=self.checksumScript(s)
def checksum(self):
"""calcul la clef de tous les scripts et tables de la bd"""
self.type='all'
self.clear()
for x in self.tables():
self[x]=self.checksumTable(x)
for x in self.scripts():
self[x]=self.checksumScript(x)
def close(self):
self.cnx.close()
def save(self, fichier=None):
"""Sauvegarde des checksum calculés dans un fichier"""
if not fichier:
strdate=datetime.datetime.today().strftime('%Y-%m-%d_%Hh%M')
model= 'checksum.%s.%s.%s.%s.txt'%(self.server.replace('\\','.'),self.database,self.type,strdate)
title='Enregistrer sous...'
fichier=tkFileDialog.asksaveasfilename(parent= Tkinter.Tk(),title=title,initialfile=model)
if fichier:
f=open(fichier,'w')
T=self.keys()
T.sort()
for t in T:
f.write('%s %i\n' % (t,self[t]))
f.close()
# ------------------------------------------------------------ OK 26-10-2011
# USAGE
# créer une nouvelle instance
s=sign()
# se connecte à une bd par nom utilisateur/mot de passe
s.connect(SERVEUR,BASE,USER,PASS)
# se connecte à une bd par authentification approuvée (LDAP)
#s.connect(SERVEUR,BASE)
# calcul des checksum des tables et des scripts (tout)
#s.checksum()
# calcul des checksum des tables
s.checksumTables()
# calcul des checksum des scripts
#s.checksumScripts()
#listes des tables
#s.tables()
#liste des scripts
#s.scripts
#Sauvegarde des checksum calculés dans un fichier
s.save()
s.close()
Deux librairies très utiles:
reportLab: qui permet d’ecrire des pdf à partir de rien doc assez complète (en) graphic paragraphe…
pyPdf: qui permet de manipuler des pdf existant notament de fusionner des pages pour produire de nouveaux pdf
Combinaison des deux permet de créer un model de formulaire et de rajouter des données à la volée pour produire rapidement de documents variable.
Dans mon cas : Un modèle riche avec mise en forme. openOffice -> modele.pdf
+ base de données dont les champs doivent être fusionnés avec le doc modèle. (la fusion native ooo ne s’avérant pas hyper clean…)
Exemple reportLab en oeuvre
from reportlab.pdfgen import canvas
from reportlab.lib.units import mm
cnv=canvas.Canvas(fichier)
cnv.setTitle('Grand titre')
cnv.setFont("Helvetica-Bold",11)
cnv.drawString(90*mm, 111*mm,'mon texte')
textobject = cnv.beginText()
textobject.setTextOrigin(135*mm, 168*mm)
textobject.setFont("Helvetica-Oblique", 8)
textobject.textLines('''ligne1.\n ligne 2...'''))
cnv.drawText(textobject)
cnv.save()
Exemple de fusion de la première pag de 2 pdfs:
#-*-coding:utf-8-*-
from pyPdf import PdfFileWriter, PdfFileReader
# pdf entrée 1
pdf_file_model = PdfFileReader(file("Model.pdf", "rb"))
pdf_page_model = pdf_file_model.getPage(0)
# pdf entrée 2
pdf_file_data = PdfFileReader(file("test.pdf", "rb"))
pdf_page_data = pdf_file_data.getPage(0)
# fusion / merge
pdf_page_model.mergePage(pdf_page_data)
# pdf sortie
output = PdfFileWriter()
# ajout les données de la fusion sur la sortie
output.addPage(pdf_page_model)
# ecrit la sortie dans un fichier
outputStream = file("doc-output.pdf", "wb")
output.write(outputStream)
outputStream.close()
LDAP
install python-ldap
apt-get install python-ldap
Authentification
#-*-coding: utf-8-*-
def ldap_auth(srv_ldap, user_dn, user_pw ):
""" Fonction qui prend un serveur ldap un nom d'utilisateur et un mot de passe
retourne True si l'utilisateur est reconnu ou pas
"""
import ldap
import sys
if user_pw and user_dn:
server=srv_ldap
try:
conx = ldap.initialize(server)
try:
conx.simple_bind_s(user_dn, user_pw)
conx.unbind()
return True
except ldap.INVALID_CREDENTIALS:
print "Your username or password is incorrect."
return False
except ldap.LDAPError, e:
if type(e.message) == dict and e.message.has_key('desc'):
print e.message['desc']
else:
print e
return False
return False
else:
return False
Champs
def ldap_get_val(srv,usr,pwd, baseDN,searchFilter, listFields): """ Entree srv = serveur ldap usr = utilisateur valide de l'annuaire pwd= mot de passe de l'utilisateur searchFilter=motif de recherche (recherche les noued contenant ce motif) listFields=liste des champs attendus Sortie Liste de liste des champs voulus """ import ldap ## first you must open a connection to the server try: #ldap.set_option(ldap.OPT_REFERRALS, 0) l=ldap.initialize(srv) l.bind(usr, pwd) l.protocol_version = ldap.VERSION3 except ldap.LDAPError, e: print e # handle error however you like ## The next lines will also need to be changed to support your search requirements and directory searchScope = ldap.SCOPE_SUBTREE ## retrieve all attributes - again adjust to your needs - see documentation for more options retrieveAttributes = None try: ldap_result_id = l.search(baseDN, searchScope, searchFilter, retrieveAttributes) result_set = [] while 1 : result_type, result_data = l.result(ldap_result_id, 0) if (result_data == []): break else: if result_type == ldap.RES_SEARCH_ENTRY: tupl=result_data[0] node=tupl[0] dic=tupl[1] result_set.append( [dic[x] for x in listFields]) return result_set except ldap.LDAPError, e: print e
#-*-coding:utf-8-*- import ldap from noyau.var import param def verifier(srv_ldap,domaine, user_dn, user_pw ): """ Fonction qui prend un serveur ldap un nom d'utilisateur et un mot de passe retourne True si l'utilisateur est reconnu ou pas """ if user_pw and user_dn: if domaine: user_dn = domaine + '\\' + user_dn try: conx = ldap.initialize(srv_ldap) try: conx.simple_bind_s(user_dn, user_pw) conx.unbind() return True except ldap.INVALID_CREDENTIALS: print "Votre identifiant ou votre mot de passe est incorrect." return False except ldap.LDAPError, e: return False else: return False