def createView( pEntity, viewTitle, userProfile ):
viewName = slugify( viewTitle )
infoEntity = getViewDefinition( pEntity , viewTitle )
# Debe corresponder al viewCodegenerado en el template ( infoEntity[viewCode] )
#viewCode = PROTO_PREFIX + viewName
try:
# Crea el Prototype ( mismo nombre q la vista : necesario para los zooms y los detalles automaticos )
rec = Prototype.objects.get_or_create( code = viewName,
smOwningTeam = userProfile.userTeam,
defaults = { 'entity_id' : pEntity.id } )[0]
except Exception:
raise Exception('can\'t create the view')
rec.metaDefinition = json.dumps( infoEntity, cls=JSONEncoder )
rec.description = infoEntity['description']
setSecurityInfo( rec, {}, userProfile, True )
rec.save()
# ----
def setSecurityLocal( dModel, userProfile ):
# need for setSecurityInfo
data = {}
try:
setSecurityInfo(dModel, data, userProfile, True )
dModel.save()
except:
return
def createView(pEntity, viewTitle, userProfile):
viewName = slugify(viewTitle)
infoEntity = getViewDefinition(pEntity, viewTitle)
# Debe corresponder al viewCodegenerado en el template ( infoEntity[viewCode] )
#viewCode = PROTO_PREFIX + viewName
try:
# Crea el Prototype ( mismo nombre q la vista : necesario para los zooms y los detalles automaticos )
rec = Prototype.objects.get_or_create(
code=viewName,
smOwningTeam=userProfile.userTeam,
defaults={'entity_id': pEntity.id})[0]
except Exception:
raise Exception('can\'t create the view')
rec.metaDefinition = json.dumps(infoEntity, cls=JSONEncoder)
rec.description = infoEntity['description']
setSecurityInfo(rec, {}, userProfile, True)
rec.save()
def extractModel(request, queryset, parameters):
"""
Copiar entidades seleccionadas en una lista sobre un modelo existente
- Si la entidad existe, toma la siguiente
- Si la entidad viene del mismo project, crea el modelos de raccordement
- Si no, solo la crea
- Se copiaran todos los elementos de datos de la entidad
parameters : entite_mod, entite_mod_id
queryset : entite
"""
if queryset.count() == 0:
return 'No record selected'
ixEntite = ['description_entite', 'historique', 'physical_name']
ixElto = [
'cle_etrangere',
'cle_primaire',
'consignes_saisie',
'contexte_particulier',
'date_creation',
'date_derniere_modification',
'date_entree_vigueur',
'date_trans_bdm',
'definition',
'domaine_valeurs',
'element_provenance',
'element_transforme',
'element_transmis',
'elements_de_source',
'exceptions',
'gabarit',
'historique',
'longueur',
'methode_transfert',
'methode_transformation',
'mode_attribution',
'nom_element_donnee',
'notes',
'numero_elem_cn',
'obligation',
'pratiques_acceptees',
'provenance_reference',
'reference_foire_questions',
'requis_par',
'si_provenance',
'statut_element',
'type_de_base',
'type_mode_attribution',
'validation_sur_element',
'validations_inter_elements',
'validations_inter_enregistrement',
'volumetrie',
]
ixRelation = [
'baseMax',
'baseMin',
'dependance',
'description',
'nom_relation',
'refMax',
'refMin',
]
from protoLib.protoAuth import getUserProfile
userProfile = getUserProfile(request.user, 'prototype', '')
# get destination model and project
from rai.models import Modele, Entite, ElementDonnee, Relation
from rai.models import ModeleRaccordement, Raccordement
lModele = Modele.objects.get(id=parameters[1]['value'])
# get source Entities
for sEntite in queryset:
dEntite = Entite.objects.get_or_create(
entite_mod=lModele, nom_entite=sEntite.nom_entite)[0]
dEntite = copyModelProps(sEntite, dEntite, ixEntite)
setSecurityInfo(dEntite, {}, userProfile, True)
dEntite.save()
# Modele de racc ( same DomAff )
dMRacc = None
if sEntite.entite_mod.domaff_modele == lModele.domaff_modele:
dMRacc = ModeleRaccordement.objects.get_or_create(
mod_modrac1=sEntite.entite_mod, mod_modrac2=lModele)[0]
setSecurityInfo(dMRacc, {}, userProfile, True)
dMRacc.save()
for sElto in sEntite.element_donnee_entite_elem.all():
dElto = ElementDonnee.objects.get_or_create(
entite_elem=dEntite,
nom_element_donnee=sElto.nom_element_donnee)[0]
dElto = copyModelProps(sElto, dElto, ixElto)
setSecurityInfo(dElto, {}, userProfile, True)
dElto.save()
if dMRacc:
dRacc = Raccordement.objects.get_or_create(
modrac_rac=dMRacc,
eledon_rac1=sElto,
eledon_rac2=dElto,
)[0]
setSecurityInfo(dRacc, {}, userProfile, True)
dRacc.save()
# new loop because relation need all entities
for sEntite in queryset:
dEntite = Entite.objects.get_or_create(
entite_mod=lModele, nom_entite=sEntite.nom_entite)[0]
for sRel in sEntite.relation_entite_rela1.all():
# get refEntity
try:
rEntite = Entite.objects.get(
entite_mod=lModele,
nom_entite=sRel.entite_rela2.nom_entite)
except Exception:
continue
# get or Create relation
dRel = Relation.objects.get_or_create(entite_rela1=dEntite,
entite_rela2=rEntite)[0]
dRel = copyModelProps(sRel, dRel, ixRelation)
setSecurityInfo(dRel, {}, userProfile, True)
dRel.save()
return
def extractModel(request, queryset, parameters):
"""
Copiar entidades seleccionadas en una lista sobre un modelo existente
- Si la entidad existe, toma la siguiente
- Si la entidad viene del mismo project, crea el modelos de raccordement
- Si no, solo la crea
- Se copiaran todos los elementos de datos de la entidad
parameters : entite_mod, entite_mod_id
queryset : entite
"""
if queryset.count() == 0:
return 'No record selected'
ixEntite = [
'description_entite',
'historique',
'physical_name'
]
ixElto = [
'cle_etrangere',
'cle_primaire',
'consignes_saisie',
'contexte_particulier',
'date_creation',
'date_derniere_modification',
'date_entree_vigueur',
'date_trans_bdm',
'definition',
'domaine_valeurs',
'element_provenance',
'element_transforme',
'element_transmis',
'elements_de_source',
'exceptions',
'gabarit',
'historique',
'longueur',
'methode_transfert',
'methode_transformation',
'mode_attribution',
'nom_element_donnee',
'notes',
'numero_elem_cn',
'obligation',
'pratiques_acceptees',
'provenance_reference',
'reference_foire_questions',
'requis_par',
'si_provenance',
'statut_element',
'type_de_base',
'type_mode_attribution',
'validation_sur_element',
'validations_inter_elements',
'validations_inter_enregistrement',
'volumetrie',
]
ixRelation = [
'baseMax',
'baseMin',
'dependance',
'description',
'nom_relation',
'refMax',
'refMin',
]
from protoLib.protoAuth import getUserProfile
userProfile = getUserProfile( request.user, 'prototype', '' )
# get destination model and project
from rai.models import Modele, Entite, ElementDonnee, Relation
from rai.models import ModeleRaccordement, Raccordement
lModele = Modele.objects.get( id = parameters[1]['value'] )
# get source Entities
for sEntite in queryset:
dEntite = Entite.objects.get_or_create( entite_mod = lModele, nom_entite = sEntite.nom_entite )[0]
dEntite = copyModelProps ( sEntite, dEntite, ixEntite)
setSecurityInfo(dEntite, {}, userProfile, True)
dEntite.save()
# Modele de racc ( same DomAff )
dMRacc = None
if sEntite.entite_mod.domaff_modele == lModele.domaff_modele :
dMRacc = ModeleRaccordement.objects.get_or_create( mod_modrac1 = sEntite.entite_mod, mod_modrac2 = lModele )[0]
setSecurityInfo(dMRacc, {}, userProfile, True)
dMRacc.save()
for sElto in sEntite.element_donnee_entite_elem.all():
dElto = ElementDonnee.objects.get_or_create( entite_elem = dEntite, nom_element_donnee = sElto.nom_element_donnee )[0]
dElto = copyModelProps( sElto, dElto, ixElto )
setSecurityInfo(dElto, {}, userProfile, True)
dElto.save()
if dMRacc:
dRacc = Raccordement.objects.get_or_create(
modrac_rac = dMRacc,
eledon_rac1 = sElto,
eledon_rac2 = dElto,
)[0]
setSecurityInfo(dRacc, {}, userProfile, True)
dRacc.save()
# new loop because relation need all entities
for sEntite in queryset:
dEntite = Entite.objects.get_or_create( entite_mod = lModele, nom_entite = sEntite.nom_entite )[0]
for sRel in sEntite.relation_entite_rela1.all():
# get refEntity
try:
rEntite = Entite.objects.get( entite_mod = lModele, nom_entite = sRel.entite_rela2.nom_entite )
except Exception:
continue
# get or Create relation
dRel = Relation.objects.get_or_create( entite_rela1 = dEntite, entite_rela2 = rEntite )[0]
dRel = copyModelProps( sRel, dRel, ixRelation )
setSecurityInfo(dRel, {}, userProfile, True)
dRel.save()
return
def writeDb(self):
# Logging info
self.__logger.info("Ecriture dans la base de donnee...")
# need for setSecurityInfo
data = {}
# We populate the database
if (self.fileTree != None): # A file has been loaded
xProjects = self.fileTree.getiterator("domain")
# ------------------------------------------------------------------------------
xModels = xProjects[0].getiterator("model")
for xModel in xModels:
dModel = Modele()
dModel.domaff_modele = self.domaff_modele
for child in xModel:
if child.tag in self.MODELE:
setattr(dModel, self.MODELE[child.tag], child.text)
try:
setSecurityInfo(dModel, data, self.userProfile, True)
dModel.save()
except Exception, e:
self.__logger.info("Error dModel.save " + str(e))
self.__logger.info("Model..." + dModel.__str__())
# ------------------------------------------------------------------------------
xEntitys = xModel.getiterator("concept")
for xEntity in xEntitys:
dEntity = Entite()
dEntity.entite_mod = dModel
for child in xEntity:
if (child.tag in self.ENTITE):
if child.text is not None:
setattr(dEntity, self.ENTITE[child.tag],
child.text)
elif type(child.attrib
) == dict and 'text' in child.attrib:
setattr(dEntity, self.ENTITE[child.tag],
child.get('text'))
try:
setSecurityInfo(dEntity, data, self.userProfile, True)
dEntity.save()
except Exception, e:
self.__logger.info("Error dEntity.save" + str(e))
self.__logger.info("Entity..." + dEntity.__str__())
# ------------------------------------------------------------------------------
xProperties = xEntity.getiterator("property")
for xProperty in xProperties:
dProperty = ElementDonnee()
dProperty.entite_elem = dEntity
for child in xProperty:
if child.tag in self.ELEMENT_DONNEE:
if (child.text is not None):
setattr(dProperty,
self.ELEMENT_DONNEE[child.tag],
child.text)
elif type(child.attrib
) == dict and 'text' in child.attrib:
setattr(dProperty,
self.ELEMENT_DONNEE[child.tag],
child.get('text'))
elif child.tag == 'udps':
for xUdp in child:
if xUdp.tag in self.ELEMENT_DONNEE_PP:
setattr(
dProperty,
self.ELEMENT_DONNEE_PP[xUdp.tag],
xUdp.get('text'))
try:
setSecurityInfo(dProperty, data, self.userProfile,
True)
dProperty.save()
except Exception, e:
self.__logger.info("Error prpDom.save" + str(e))
# Relationship -------------------------------------------------------------------
xForeigns = xEntity.getiterator("foreign")
for xForeign in xForeigns:
dForeign = Relation()
dForeign.entite_rela1 = dEntity
dForeign.entite_rela2 = dEntity
for child in xForeign:
if child.tag in self.RELATION:
setattr(dForeign, self.RELATION[child.tag],
child.text)
try:
setSecurityInfo(dForeign, data, self.userProfile,
True)
dForeign.save()
except Exception, e:
self.__logger.info("Error dForeign.save" + str(e))
# RAC
# ------------------------------------------------------------------------------
xLinkModels = xProjects[0].getiterator("linkModel")
for xLinkModel in xLinkModels:
dLinkModel = ModeleRaccordement()
dLinkModel.tmp_domaff = self.domaff_modele
for child in xLinkModel:
if child.tag in self.MODELE_RACCORDEMENT:
setattr(dLinkModel,
self.MODELE_RACCORDEMENT[child.tag],
child.text)
try:
setSecurityInfo(dLinkModel, data, self.userProfile, True)
dLinkModel.save()
except Exception, e:
self.__logger.info("Error dLinkModel.save" +
dLinkModel.__str__() + str(e))
self.__logger.info("LinkModel..." + dLinkModel.__str__())
# ------------------------------------------------------------------------------
xLinks = xLinkModel.getiterator("link")
for xLink in xLinks:
dLink = Raccordement()
dLink.modrac_rac = dLinkModel
for child in xLink:
if (child.tag in self.RACCORDEMENT) and (child.text
def __write(self):
# Logging info
self.__logger.info("Ecriture dans la base de donnee...")
# Los elementos superXXX son referencias de tipo caracter,
fdsModel = ('code', 'category', 'modelPrefix',)
fdsEntity = ('code',)
# fdsProperty = ( 'code', 'alias', 'physicalName', 'foreignEntity' )
fdsProperty = ('code',)
booProperty = ('isPrimary', 'isNullable', 'isRequired', 'isSensitive', 'isEssential',)
fdsRelationship = ('code', 'baseMin', 'baseMax', 'refMin', 'refMax',)
# need for setSecurityInfo
data = {}
# We populate the database
if (self.__tree != None): # A file has been loaded
xProjects = self.__tree.getiterator("domain")
# ------------------------------------------------------------------------------
xModels = xProjects[0].getiterator("model")
for xModel in xModels:
dModel = Model()
dModel.project = self.project
modelUdps = []
for child in xModel:
if child.tag in fdsModel:
setattr(dModel, child.tag, child.text)
elif child.tag == 'udps':
for xUdp in child:
modelUdps.append((xUdp.tag, xUdp.get('text')))
try:
setSecurityInfo(dModel, data, self.userProfile, True )
dModel.save()
except:
self.__logger.info("Error dModel.save")
return
self.__logger.info("Model..." + dModel.code)
# ------------------------------------------------------------------------------
xEntitys = xModel.getiterator("concept")
for xEntity in xEntitys:
dEntity = Entity()
dEntity.model = dModel
for child in xEntity:
if (child.tag in fdsEntity):
if (child.text is not None):
setattr(dEntity, child.tag, child.text)
elif (child.tag == 'physicalName'):
setattr(dEntity, 'dbName' , child.text)
try:
setSecurityInfo(dEntity, data, self.userProfile, True )
dEntity.save()
except:
self.__logger.info("Error dEntity.save")
return
self.__logger.info("Entity..." + dEntity.code)
# ------------------------------------------------------------------------------
xProperties = xEntity.getiterator("property")
for xProperty in xProperties:
dProperty = Property()
dProperty.entity = dEntity
for child in xProperty:
if child.tag in fdsProperty:
if (child.text is not None):
setattr(dProperty, child.tag, child.text)
elif child.tag in booProperty:
bValue = toBoolean(child.text)
setattr(dProperty, child.tag, bValue)
try:
setSecurityInfo(dProperty, data, self.userProfile, True )
dProperty.save()
except:
self.__logger.info("Error prpDom.save")
return
# Relationship -------------------------------------------------------------------
xForeigns = xEntity.getiterator("foreign")
for xForeign in xForeigns:
dForeign = Relationship()
dForeign.entity = dEntity
dForeign.refEntity = dEntity
for child in xForeign:
if child.tag in fdsRelationship:
setattr(dForeign, child.tag, child.text)
elif (child.tag == 'baseConcept'):
setattr(dForeign, 'dbName' , child.text)
elif (child.tag == 'alias'):
setattr(dForeign, 'relatedName' , child.text)
elif child.tag in booProperty:
bValue = toBoolean(child.text)
setattr(dForeign, child.tag, bValue)
try:
setSecurityInfo(dForeign, data, self.userProfile, True )
dForeign.save()
except Exception, e:
self.__logger.info("Error dForeign.save" + str(e))
return
