def getFieldIncrement(request):
success = False
fieldName = request.GET['fieldName']
viewEntity = request.GET['viewEntity']
try:
model = getDjangoModel(viewEntity)
except :
return JsonError('model not found:' + viewEntity)
fieldType = model._meta.get_field(fieldName).get_internal_type()
increment = 0
if fieldType == 'IntegerField':
maxid = model.objects.aggregate(Max('id'))
if maxid['id__max']:
increment = maxid['id__max'] + 1
else:
increment = 1
else:
return JsonError('Invalid field type')
if increment > 0:
success = True
jsondict = {
'success': success,
'increment': increment
}
json_data = json.dumps(jsondict)
return HttpResponse(json_data, content_type="application/json")
def protoCsv(request):
# Create the HttpResponse object with the appropriate CSV header, based of fieldDefinition
if not request.user.is_authenticated():
return JsonError('readOnly User')
if request.method != 'POST':
return JsonError( 'invalid message' )
protoMeta = request.POST.get('protoMeta', '')
protoMeta = json.loads(protoMeta)
protoFilter = request.POST.get('protoFilter', '')
baseFilter = request.POST.get('baseFilter', '')
sort = request.POST.get('sort', '')
# Obtiene las filas del modelo
Qs, orderBy, fakeId, refAllow = getQSet( protoMeta, protoFilter, baseFilter , sort , request.user )
# El refAllow no es necesario para reportes
refAllow = refAllow and False
if orderBy:
pRows = Qs.order_by(*orderBy)
else:
pRows = Qs.all()
# Prepara las cols del Query
try:
pList = Q2Dict(protoMeta , pRows, fakeId )
except Exception, e:
message = getReadableError( e )
pList = [ message ]
def changepassword(request):
if request.method != 'POST':
return JsonError('invalid message')
newpass1 = request.POST['newPassword1']
newpass2 = request.POST['newPassword2']
userName = request.POST['login']
userPwd = request.POST['current']
try:
pUser = authenticate(username=userName, password=userPwd)
except:
pUser = None
errMsg = "Mauvais utilisateur ou mot de passe"
if pUser is not None:
if newpass1 == newpass2:
user = User.objects.get(username=userName)
user.set_password(newpass1)
user.save()
if user.email:
try:
message = _(u'Votre mot de passe a été réinitialisé '
) + ' : %s' % (newpass1)
message += ' \n\n%s : %s' % (_(u'Utilisateur'), user)
user.email_user(_('Nouveau mot de passe'), message)
except:
pass
return JsonSuccess()
else:
errMsg = 'Les mots de passe ne correspondent pas!'
return JsonError(_(errMsg))
def protoGetFieldTree(request):
""" return full field tree
"""
if request.method != 'POST':
return JsonError('Invalid message')
viewCode = request.POST.get('viewCode', '')
viewEntity = getBaseModelName(viewCode)
try:
model = getDjangoModel(viewEntity)
except Exception as e:
return JsonError(getReadableError(e))
fieldList = []
if viewCode.startswith(PROTO_PREFIX) and viewCode != viewEntity :
# --------------------------------------------------- Prototipos
protoEntityId = request.POST.get('protoEntityId')
if not protoEntityId >= 0:
return JsonError('invalid idEntity')
try:
from prototype.actions.viewDefinition import GetProtoFieldsTree
fieldList = GetProtoFieldsTree(protoEntityId)
except:
return JsonError('invalid idEntity')
else:
# -----------------------------------------------------------------------------------------------------
# Se crean los campos con base al modelo ( trae todos los campos del modelo
# for field in model._meta._fields(): # only for django 1.4
for field in model._meta.fields:
try:
addFiedToList(fieldList, field , '')
except Exception as e:
traceback.print_exc()
return JsonError(getReadableError(e))
# Add __str__
myField = {
'id' : '__str__' ,
'text' : '__str__' ,
'checked' : False,
'leaf' : True
}
# Defaults values
setDefaultField(myField, model , viewCode)
# FormLink redefinition to original view
# myField['zoomModel'] = viewCode
fieldList.append(myField)
# Codifica el mssage json
context = json.dumps(fieldList)
return HttpResponse(context, content_type="application/json")
def sheetConfigRep(request):
""" Reporte basado en la definicion de plantillas ( sheets )
"""
if not request.user.is_authenticated():
return JsonError('readOnly User')
if request.method != 'POST':
return JsonError('invalid message')
""" 1.
Recibe opcion, plantilla base, Qs ( lista de ids )
La plantilla de base sera solicitada al usuario, si se deja en blanco usara el sheetSelector o el default
Los detalles no tienen selector, siempre se usara el template marcado en el detalle.
"""
viewCode = request.POST.get('viewCode', '')
sheetName = request.POST.get('sheetName', '')
selectedKeys = request.POST.get('selectedKeys', [])
selectedKeys = json.loads( selectedKeys )
protoMeta, Qs = getReportBase( viewCode )
# Si no hay lista, los trae todos
if type( selectedKeys ).__name__ == type([]).__name__ and selectedKeys.__len__() > 0:
pFilter = { 'pk__in' : selectedKeys }
Qs = addFilter( Qs, pFilter )
# template FirstPage
pSheet = getSheetConf ( protoMeta, sheetName )
sheetName = pSheet.get( 'name' , 'Auto')
# Obtiene el template FirstPage
templateFp = pSheet.get( 'templateFp' , '<span ' + sheetName + '.firstPage></span>')
templateFp = templateFp + pSheet.get( 'templateBb' , '<span ' + sheetName + '.BeforeBlock></span>')
templateLp = pSheet.get( 'templateAb' , '<span ' + sheetName + '.AfterBlock></span>')
templateLp = templateLp + pSheet.get( 'templateLp' , '<span ' + sheetName + '.lastPage></span>')
templateEr = pSheet.get( 'templateEr' , pSheet.get( 'template', '' ) )
# Variables de titulo
templateFp = getReport( ['reportTitle'], templateFp, {'reportTitle' : pSheet.get( 'title', sheetName )} )
# Crea la clase del reporte
MyReport = SheetReportFactory()
# Envia al reporte la hoja para manejar los detalles, el QSet, y los templates
MyReport.getReport( Qs, templateFp, templateEr, templateLp, protoMeta, pSheet.get( 'sheetDetails' , [] ))
# retorna el reporte
return HttpResponse(MyReport.myReport )
def protoGetPasswordRecovery(request):
baseURI = request.build_absolute_uri('..')
if request.POST.get('email') and request.POST.get('login'):
try:
u = User.objects.get(email=request.POST['email'],
username=request.POST['login'])
token = user_token(u)
if settings.HOST_DOMAIN:
baseURI = 'http://' + settings.HOST_DOMAIN + '/protoLib/'
link = baseURI + 'resetpassword?a=%s&t=%s' % (u.pk, token)
email_template_name = 'recovery/recovery_email.txt'
body = loader.render_to_string(email_template_name).strip()
message = _(body)
message += ' %s\n\n%s : %s' % (link, _(u'Utilisateur'),
request.POST['login'])
message += ' \n\n%s' % (_(
u'Si vous ne voulez pas réinitialiser votre mot de passe, il suffit d\'ignorer ce message et il va rester inchangé'
))
u.email_user(_('Nouveau mot de passe'), message)
return JsonSuccess()
except:
return JsonError(_("Utilisateur non trouvé"))
return HttpResponseRedirect('/')
def protoGetDetailsTree(request):
""" return full field tree
"""
if not request.user.is_authenticated():
return JsonError('readOnly User')
if request.method != 'POST':
return JsonError('invalid message')
viewCode = request.POST.get('viewCode', '')
viewEntity = getBaseModelName(viewCode)
try:
model = getDjangoModel(viewEntity)
except Exception, e:
jsondict = {'success': False, 'message': getReadableError(e)}
context = json.dumps(jsondict)
return HttpResponse(context, content_type="application/json")
def protoGetUserRights(request):
""" return usr rights
"""
if request.method != 'POST':
return JsonError('invalid message')
userName = request.POST['login']
userPwd = request.POST['password']
errMsg = ''
success = False
language = None
try:
pUser = authenticate(username=userName, password=userPwd)
except:
pUser = None
userInfo = {'userName': userName}
if pUser is not None:
if pUser.is_active:
login(request, pUser)
success = True
userInfo['isStaff'] = pUser.is_staff
userInfo['isSuperUser'] = pUser.is_superuser
userInfo['fullName'] = pUser.get_full_name()
# Si es login retorna la lengua del usuario
language = getUserProfile(pUser, 'login', userName)
else:
# Return a 'disabled account' error message
errMsg = "Cet utilisateur est desactivé"
else:
# Return an 'invalid login' error message.
errMsg = "Mauvais utilisateur ou mot de passe"
jsondict = {
'success': success,
'message': errMsg,
'userInfo': userInfo,
'language': language
}
# Encode json
context = json.dumps(jsondict)
return HttpResponse(context, content_type="application/json")
def protoGetPCI(request):
""" return full metadata (columns, renderers, totalcount...)
"""
if not request.user.is_authenticated():
return JsonError('readOnly User')
if request.method != 'POST':
return JsonError('invalid message')
viewCode = request.POST.get('viewCode', '')
viewEntity = getBaseModelName(viewCode)
try:
model = getDjangoModel(viewEntity)
except :
return JsonError('model not found:' + viewEntity)
#
userProfile = getUserProfile(request.user, 'getPci', viewEntity)
# PROTOTIPOS
if viewCode.startswith(PROTO_PREFIX) and viewCode != viewEntity :
try:
prototypeView = viewCode.replace(PROTO_PREFIX, '')
protoDef = Prototype.objects.get(code=prototypeView, smOwningTeam=userProfile.userTeam)
created = False
except:
jsondict = { 'success':False, 'message': viewCode + ' notFound' }
return HttpResponse(json.dumps(jsondict), content_type="application/json")
else:
# created : El objeto es nuevo
# protoDef : PCI leida de la DB
protoDef, created = ProtoDefinition.objects.get_or_create(code=viewCode)
# Verifica si es una version vieja
if created:
protoDef.overWrite = True
# active solo viene de protoDefinition
try:
active = protoDef.active
except:
active = True
# Si es nuevo o no esta activo lee Django
if created or (not active) :
model_admin, protoMeta = getProtoAdmin(model)
version = protoMeta.get('metaVersion')
# La version determina q es una carga completa de la meta y no es necesario reconstruirla
# solo en caso de q la definicion no este en la Db
if (version is None) or (version < PROTOVERSION):
# Verifica si existe una propiedad ProtoMeta es la copia de la meta cargada a la Db,
grid = protoGrid.ProtoGridFactory(model, viewCode, model_admin, protoMeta)
protoMeta = createProtoMeta(model, grid, viewEntity, viewCode)
# Guarda la Meta si es nuevo o si se especifica overWrite
if created or protoDef.overWrite:
protoDef.metaDefinition = json.dumps(protoMeta)
protoDef.description = protoMeta['description']
protoDef.save()
else:
protoMeta = json.loads(protoDef.metaDefinition)
protoMeta['viewCode'] = viewCode
# La definicion del arbol es fija, pues las cols deben ser siempre uniformes sin importar el tipo de modelo.
# pStyle = protoMeta.get( 'pciStyle', '')
# if pStyle == 'tree': setTreeDefinition()
customCode = '_custom.' + viewCode
try:
custom = CustomDefinition.objects.get(code=customCode, smOwningTeam=userProfile.userTeam)
custom = json.loads(custom.metaDefinition)
protoMeta['custom'] = custom['custom']
except:
pass
# TODO: Verificacion de la metadata
# try:
# protoMeta = verifyMeta(protoMeta, 'pcl')
# except Exception, e:
# traceback.print_exc()
# message = getReadableError(e)
# WorkFlow
if hasattr(model , '_WorkFlow') :
wflowControl = getattr(model, '_WorkFlow', {})
if request.user.is_superuser or getModelPermissions(request.user , model, 'wfadmin') :
protoMeta['WFlowActions'] = wflowControl.get('transitions', [])
wfFilterSet = wflowControl.get('wfFilters', [])
if len(wfFilterSet) > 0:
protoMeta['gridSets'] = protoMeta.get('gridSets', {})
protoMeta['gridSets']['filtersSet'] = wfFilterSet
for lFilter in wfFilterSet:
lFilter['customFilter'] = [{
"property": "smWflowStatus",
"filterStmt": lFilter[ 'wfStatus']
}]
jsondict = {
'success':True,
'message': '',
'metaData':{
# The name of the property which contains the Array of row objects. ...
'root': 'rows',
# Name of the property within a row object that contains a record identifier value. ...
'idProperty': protoMeta['idProperty'],
# Name of the property from which to retrieve the total number of records in t
'totalProperty':'totalCount',
# Name of the property from which to retrieve the success attribute. ...
'successProperty':'success',
# The name of the property which contains a response message. (optional)
'messageProperty': 'message',
},
'protoMeta': protoMeta,
'permissions': getModelPermissions(request.user, model),
'rows':[],
'totalCount': 0,
}
# Codifica el mssage json
context = json.dumps(jsondict)
return HttpResponse(context, content_type="application/json")
def protoSaveProtoObj(request):
""" Save full metadata
* objetos del tipo _XXX se guardan siempre en CustomDefinition
* objetos del tipo prototype.protoTable se guardan siempre en Prototype
* Solo los adminstradores tienen el derecho de guardar pcls
custom : Los objetos de tipo custom, manejan la siguiente llave
_ColSet.[viewCode] listDisplaySet
_QrySet.[viewCode] filterSet
_menu
Para manejar el modelo en las generacion de protoPci's se usa :
prototype.protoTable.[protoModel-viewCode] --> al leer la pcl se leera prototype.protoTable.[protoModel-viewCode]
"""
if request.method != 'POST':
return JsonError('invalid message')
custom = False
prototype = False
create = False
viewCode = request.POST.get('viewCode', '')
userProfile = getUserProfile(request.user, 'saveObjs', viewCode)
# Reglas para definir q se guarda
if viewCode.find('_') == 0 :
custom = True
if viewCode.startswith(PROTO_PREFIX) :
prototype = True
# Carga la meta
sMeta = request.POST.get('protoMeta', '')
# Es customProperty
if custom:
try:
protoDef, create = CustomDefinition.objects.get_or_create(code=viewCode, smOwningTeam=userProfile.userTeam)
except Exception as e:
return JsonError(getReadableError(e))
# Es prototype
elif prototype:
try:
# debe existir previamente
protoCode = viewCode.replace(PROTO_PREFIX, '')
protoMeta = json.loads(sMeta)
entityId = protoMeta['protoEntityId']
entityObj = Entity.objects.get(id=entityId)
protoDef, create = Prototype.objects.get_or_create(code=protoCode, entity=entityObj, smOwningTeam=userProfile.userTeam)
except Exception as e:
return JsonError(getReadableError(e))
else:
# Verifica los permisos
viewEntity = getBaseModelName(viewCode)
model = getDjangoModel(viewEntity)
if not getModelPermissions(request.user, model, 'config') :
return JsonError('permission denied')
try:
protoDef = ProtoDefinition.objects.get_or_create(code=viewCode)[0]
except Exception as e:
return JsonError(getReadableError(e))
protoDef.active = True
protoDef.overWrite = False
# borra el custom por q confunde haecer modif en un lado y otro
try:
CustomDefinition.objects.filter(code='_custom.' + viewCode, smOwningTeam=userProfile.userTeam).delete()
except:
pass
if custom or prototype:
setSecurityInfo(protoDef, {}, userProfile, create)
protoDef.metaDefinition = sMeta
protoDef.save()
return JsonSuccess({ 'message': 'Ok' })
viewCode = request.POST.get('viewCode', '')
viewEntity = getBaseModelName(viewCode)
try:
model = getDjangoModel(viewEntity)
except Exception, e:
jsondict = {'success': False, 'message': getReadableError(e)}
context = json.dumps(jsondict)
return HttpResponse(context, content_type="application/json")
detailList = []
if viewCode.startswith(PROTO_PREFIX) and viewCode != viewEntity:
# ------------------------------------------------------------------------- Prototipos
protoEntityId = request.POST.get('protoEntityId')
if not protoEntityId >= 0:
return JsonError('invalid idEntity')
try:
from prototype.actions.viewDefinition import GetDetailsConfigTree
detailList = GetDetailsConfigTree(protoEntityId)
except:
return JsonError('invalid idEntity')
else:
modelDetails = getModelDetails(model)
for detail in modelDetails:
addDetailToList(detailList, detail, '')
# Codifica el mssage json
context = json.dumps(detailList)
return HttpResponse(context, content_type="application/json")
def protoGetMenuData(request):
"""
Cada grupo tiene su propio menu q se construye con las app a las cuales tiene derecho
se guarda siempre por grupo en customDefinition,
Cada usuario tendra una rama de favoritos para sus opciones frecuentes,
el menu es a nivel de grupo
"""
global ix
if not request.user.is_authenticated():
return JsonError('readOnly User')
if request.method != 'POST':
return JsonError('invalid message')
currentUser = request.user
userProfile = getUserProfile(currentUser, 'getMenu', '')
app_dict = {}
appAux = cAux()
appAux.ixApp = 1
appAux.ixMod = 1
def getMenuItem(protoAdmin, model, menuNode):
appCode = model._meta.app_label
# Define la rama del menu
try:
menuLabel = model.protoExt["menuApp"]
except:
menuLabel = appCode
if menuLabel in ['contenttypes', 'sites']:
menuLabel = 'auth'
# Verifica q el usuairo tenga permiso, considera el admin
if not getModelPermissions(currentUser, model, 'menu') :
return
pTitle = protoAdmin.get('title', model._meta.verbose_name.title())
# Obtiene el menu de settigs.PROTO_APP
try:
menuDefinition = settings.PROTO_APP.get('app_menu', {}).get(menuLabel, {})
except:
menuDefinition = {}
if menuDefinition.get('hidden', False):
return
# Icono por defecto
viewIcon = protoAdmin.get('viewIcon', 'icon-1')
model_dict = {
'viewCode': appCode + '.' + menuNode ,
'text': pTitle ,
'index': appAux.ixMod ,
'iconCls': viewIcon ,
'leaf': True,
}
if menuLabel in app_dict:
app_dict[menuLabel]['children'].append(model_dict)
else:
app_dict[menuLabel] = {
'text': menuDefinition.get('title', menuLabel) ,
'expanded': menuDefinition.get('expanded', False) ,
'index': menuDefinition.get('menu_index', appAux.ixApp),
'children': [model_dict],
}
appAux.ixApp += 1
appAux.ixMod += 1
#-- Lectura de la Db -------------------------------------------------------------
forceDefault = request.POST.get('forceDefault', '')
viewCode = '__menu'
protoDef = CustomDefinition.objects.get_or_create(
code=viewCode, smOwningTeam=userProfile.userTeam,
defaults={'active': False, 'code' : viewCode, 'smOwningTeam' : userProfile.userTeam }
)[0]
# El default solo parece funcionar al insertar en la Db
if protoDef.active and (forceDefault == '0') :
context = protoDef.metaDefinition
else:
for model in models.get_models(include_auto_created=True):
# for model, model_admin in site._registry.items():
# protoAdmin = getattr(model_admin, 'protoExt', {})
menuNode = model._meta.object_name
protoAdmin = getattr(model, 'protoExt', {})
getMenuItem(protoAdmin, model, menuNode)
# Sort the apps alphabetically.
app_list = app_dict.values()
app_list.sort(key=lambda x: x['index'])
# Sort the models alphabetically within each app.
for app in app_list:
app['children'].sort(key=lambda x: x['index'])
# lee las opciones del prototipo -----------------------------------------------
prototypes = Prototype.objects.filter(smOwningTeam=userProfile.userTeam)
prNodes = {
'text': 'ProtoOptions' ,
'expanded': True ,
'index': 1000 ,
'children': [],
'leaf': False
}
app_list.append(prNodes)
ix = 0
for option in prototypes:
prBase = getNodeBaseProto(prNodes, option)
prBase['children'].append({
'text': option.code,
'expanded': True ,
'viewCode': PROTO_PREFIX + option.code,
'iconCls': 'icon-proto',
'index': ix,
'leaf': True
})
ix += 1
# lee las vistas
prototypes = ProtoDefinition.objects.all()
prNodes = {
'text': 'ProtoViews' ,
'expanded': True ,
'index': 2000 ,
'children': [],
'leaf': False
}
app_list.append(prNodes)
ix = 0
for option in prototypes:
prBase = getNodeBaseViews(prNodes, option)
prBase['children'].append({
'text': option.code,
'expanded': True ,
'viewCode': option.code,
'iconCls': 'icon-1',
'index': ix,
'leaf': True
})
ix += 1
# Pega el menu sobre la definicion anterior
try:
menuAux = []
menuTmp = verifyList(json.loads(protoDef.metaDefinition))
for menuOp in menuTmp:
if menuOp.get( 'text', '') != 'AutoMenu':
menuAux.append (menuOp)
menuAux.append({
'id': 'prototype.auto.nodes' ,
'text': 'AutoMenu' ,
'expanded': True,
'index': 1000 ,
'children': app_list,
'leaf': False
})
except:
menuAux = app_list
context = json.dumps(menuAux)
# Lo guarda ( created : true --> new
protoDef.metaDefinition = context
protoDef.active = True
protoDef.description = 'Menu'
setSecurityInfo(protoDef, {}, userProfile, True)
protoDef.save()
return HttpResponse(context, content_type="application/json")