def jxSave(request, **args):
"""
Save register. Operation executed when clicking on "Save" button on forms. Saves all instances related to forms, included
many to many relationships.
** Attributes **
* ``request``
* ``**args``
"""
logger.debug("jxSave...")
logger.debug(json.dumps(request.REQUEST.items()))
request.session.set_test_cookie()
request.session.delete_test_cookie()
if (request.REQUEST.has_key("action")) and request.is_ajax() == True:
action = request.REQUEST["action"]
logger.debug("action: %s" % (action))
if action == "save":
# resolve form, set to args['ctx'].form
logger.debug("jxSave :: form: %s" % (request.REQUEST["form"]))
formId = request.REQUEST["form"]
app = request.REQUEST["app"]
app_path = get_app_full_path(app)
logger.debug("formId: {} app: {} app_path: {}".format(formId, app, app_path))
formModule = getattr(getattr(__import__(app_path + ".forms"), app_path.split(".")[1]), "forms")
logger.debug("formModule: {}".format(formModule))
classes = dir(formModule)
resolvedForm = None
for myClass in classes:
try:
formIdTarget = eval("formModule." + myClass + "._XP_FORM_ID")
if formIdTarget == formId:
resolvedForm = eval("formModule." + myClass)
except AttributeError:
pass
logger.debug("jxSave :: resolvedForm: %s" % (resolvedForm))
# Instantiate form, validate form
logger.debug("jxSave :: post: %s" % (args["ctx"].post))
# instantiate form for create and update with db instances dbObjects from form
# dbObjects : pk, model
instances = {}
dbObjects = json.loads(args["ctx"].post["dbObjects"].replace("'", '"'))
logger.debug("jxSave :: dbObjects: %s" % (dbObjects))
# TODO: In case we support more masters than 'default', resolve appropiate master db name
for key in dbObjects:
# Get instance model by pk
impl = dbObjects[key]["impl"]
cls = get_class(impl)
instances[key] = cls.objects.using("default").get(pk=dbObjects[key]["pk"])
logger.debug("jxSave :: instances. %s" % (instances))
if len(instances) == 0:
args["ctx"].form = resolvedForm(args["ctx"].post, ctx=args["ctx"])
else:
args["ctx"].form = resolvedForm(args["ctx"].post, ctx=args["ctx"], instances=instances)
logger.debug("jxSave :: instantiated form")
args["ctx"].jsData = JsResultDict()
isFormValid = args["ctx"].form.is_valid()
# isFormValid = False
logger.debug("jxSave :: isFormValid: %s" % (isFormValid))
obj = CommonService(args["ctx"])
obj.request = request
if isFormValid == True:
logger.debug("jxSave :: Form is valid!!!")
obj._set_main_form(args["ctx"].form)
result = obj.save()
else:
if settings.DEBUG == True:
logger.debug("Validation error!!!!!")
logger.debug(args["ctx"].form.errors)
if args["ctx"].form.errors.has_key("invalid"):
logger.debug(args["ctx"].form.errors["invalid"])
traceback.print_exc()
if args["ctx"].form.errors.has_key("invalid"):
errorDict = {"": args["ctx"].form.errors["invalid"][0]}
logger.debug("errorDict: %s" % (errorDict))
result = obj._buildJSONResult(obj._getErrorResultDict(errorDict, pageError=True))
else:
# Build errordict
errorDict = {}
for field in args["ctx"].form.errors:
if field != "__all__":
errorDict[field] = args["ctx"].form.errors[field][0]
logger.debug("errorDict: %s" % (errorDict))
result = obj._buildJSONResult(obj._getErrorResultDict(errorDict, pageError=False))
return result
else:
logger.debug("Invalid action name. Only save is allowed")
raise Http404
else:
logger.debug("Unvalid business request")
raise Http404
return result
def jxDataQuery(request, **args):
"""
Execute data queries for lists with ordering, page and filters.
** Attributes **
* ``request``
* ``args``
** Html Attributes **
* ``dbClass``:str : Data class name (DAO)
* ``fields``:list<str> [optional]
* ``pageStart``:str [optional] [default:1] : Start page number
* ``pageEnd``:str [optional] : End page number
* ``orderBy``:tuple<str> [optional]
* ``method``:str [optional] [default:searchFields]
* ``args``:dict<str,str> [optional]
* ``hasOrdering``:bool [optional]
* ``orderField``:str [optional]
** Returns **
result
"""
logger.debug("jxDataQuery...")
logger.debug("jxDataQuery :: args: %s" % (args))
logger.debug("jxDataQuery :: REQUEST: %s" % (request.REQUEST))
if not request.REQUEST.has_key("dbClass") or not request.REQUEST.has_key("app"):
raise XpMsgException(AttributeError, _("app and dbClass must be defined."))
dbClass = request.REQUEST["dbClass"]
dbApplication = ApplicationDAO(args["ctx"])
# logger.debug('jxDataQuery :: app: {}'.format(request.REQUEST['app'], get_app_full_path(request.REQUEST['app'])))
app = get_app_full_path(request.REQUEST["app"])
application = dbApplication.get(name=app)
# app: ximpia_site.web, MyDAO => ximpia_site.web.data.MyDAO
classPath = app + ".data." + dbClass
cls = get_class(classPath)
obj = cls(args["ctx"]) # @UnusedVariable
obj.request = request
logger.debug("jxDataQuery :: obj: %s" % (obj))
# fields
fields = []
if request.REQUEST.has_key("fields"):
fields = json.loads(request.REQUEST["fields"])
dbArgs = {}
meta = AttrDict()
# disablePaging
dbArgs["disable_paging"] = False
if request.REQUEST.has_key("disablePaging"):
dbArgs["disable_paging"] = json.loads(request.REQUEST["disablePaging"])
if not dbArgs["disable_paging"]:
if request.REQUEST.has_key("pageStart"):
dbArgs["page_start"] = int(request.REQUEST["pageStart"])
else:
dbArgs["page_start"] = 1
logger.debug("jxDataQuery :: pageStart: %s" % (dbArgs["page_start"]))
# pageEnd
if request.REQUEST.has_key("pageEnd") and not dbArgs["disable_paging"]:
dbArgs["page_end"] = int(request.REQUEST["pageEnd"])
# orderBy
if request.REQUEST.has_key("orderBy"):
dbArgs["order_by"] = json.loads(request.REQUEST["orderBy"])
# args
if request.REQUEST.has_key("args"):
requestArgs = json.loads(request.REQUEST["args"])
for requestArg in requestArgs:
try:
dbArgs[requestArg] = json.loads(requestArgs[requestArg])
except ValueError:
dbArgs[requestArg] = requestArgs[requestArg]
# numberResults
if request.REQUEST.has_key("numberResults"):
dbArgs["number_results"] = int(request.REQUEST["numberResults"])
else:
# Get number results from settings
dbArgs["number_results"] = int(Setting.objects.get(name__name=KSite.SET_NUMBER_RESULTS_LIST).value)
logger.debug("jxDataQuery :: numberResults: %s" % (dbArgs["number_results"]))
# hasOrdering
if request.REQUEST.has_key("hasOrdering") and request.REQUEST["hasOrdering"] == "true":
if request.REQUEST.has_key("orderField"):
fields.append(request.REQUEST["orderField"])
else:
fields.append("order")
# hasHeader
hasHeader = False
if request.REQUEST.has_key("hasHeader"):
hasHeader = json.loads(request.REQUEST["hasHeader"])
logger.debug("jxDataQuery :: hasHeader: %s" % (hasHeader))
if "id" not in fields and len(fields) != 0:
fields.insert(0, "id")
logger.debug("jxDataQuery :: fields: %s" % (fields))
logger.debug("jxDataQuery :: dbArgs: %s" % (dbArgs))
"""dbArgs['disablePaging'] = False
dbArgs['pageStart'] = 1
dbArgs['pageEnd'] = 1
dbArgs['numberResults'] = 2"""
if request.REQUEST.has_key("method"):
dataListTmp = eval("obj." + request.REQUEST["method"])(fields, **dbArgs)
else:
dataListTmp = obj.search_fields(fields, **dbArgs)
# numberPages
if dbArgs["disable_paging"] is not True:
dbArgsPages = copy.copy(dbArgs)
if dbArgsPages.has_key("page_start"):
del dbArgsPages["page_start"]
if dbArgsPages.has_key("page_end"):
del dbArgsPages["page_end"]
if request.REQUEST.has_key("method"):
"""dataListTmp = eval('obj.' + request.REQUEST['method'])(fields, **dbArgsPages)
logger.debug('jxDataQuery :: type dataListTmp: %s' % (type(dataListTmp)) )
meta.numberPages = dataListTmp.count()/numberResults"""
pass
else:
if dbArgsPages.has_key("disable_paging"):
del dbArgsPages["disable_paging"]
if dbArgsPages.has_key("number_results"):
numberResults = dbArgsPages["number_results"]
del dbArgsPages["number_results"]
if dbArgsPages.has_key("page_start"):
del dbArgsPages["page_start"]
if dbArgsPages.has_key("page_end"):
del dbArgsPages["page_end"]
if dbArgsPages.has_key("order_by"):
del dbArgsPages["order_by"]
meta.numberPages = int(round(float(obj.model.objects.filter(**dbArgsPages).count()) / float(numberResults)))
else:
meta.numberPages = 1
meta.pageStart = 1
if dbArgs.has_key("page_start"):
meta.pageStart = dbArgs["page_start"]
if dbArgs.has_key("page_end"):
meta.pageEnd = dbArgs["page_end"]
else:
meta.pageEnd = meta.pageStart
# logger.debug('jxDataQuery :: dataListTmp: %s' % (dataListTmp) )
dataList = []
for dbFields in dataListTmp:
ll = []
for dbField in dbFields:
if type(dbField) == datetime.date:
ll.append(dbField.strftime("%m/%d/%Y"))
elif type(dbField) == datetime.datetime:
ll.append(dbField.strftime("%m/%d/%Y %H:%M"))
elif type(dbField) == datetime.time:
ll.append(dbField.strftime("%H:%M"))
else:
ll.append(dbField)
dataList.append(ll)
logger.debug("jxDataQuery :: dataList: %s" % (dataList))
# headers
headers = []
if hasHeader:
modelFields = obj.model._meta.fields
logger.debug("jxDataQuery :: modelFields: %s" % (modelFields))
if len(fields) == 0:
# get all model fields from table and add to headers
for modelField in modelFields:
headers.append(modelField.verbose_name)
else:
# Get model fields with max level 3: field__field__field
for field in fields:
if field.count("__") == 0:
headerField = obj.model._meta.get_field_by_name(field)[0].verbose_name
logger.debug("jxDataQuery :: headerField: %s" % (headerField))
headers.append(headerField)
elif field.count("__") == 1:
fieldFrom, fieldTo = field.split("__")
logger.debug("jxDataQuery :: fieldFrom: %s fieldTo: %s" % (fieldFrom, fieldTo))
"""relField = obj.model._meta.get_field_by_name(fieldFrom)[0]\
.rel.to._meta.get_field_by_name(fieldTo)[0]"""
# 03/07/2013 : We get header name from fk verbose name and not linked to verbose name
relField = obj.model._meta.get_field_by_name(fieldFrom)[0]
if type(relField.verbose_name) == types.UnicodeType:
headerField = relField.verbose_name
else:
headerField = relField.name
logger.debug("jxDataQuery :: headerField: %s" % (headerField))
headers.append(headerField)
elif field.count("__") == 2:
fieldFrom, fieldTo1, fieldTo2 = field.split("__")
logger.debug("jxDataQuery :: fieldFrom: %s fieldTo: %s" % (fieldFrom, fieldTo1, fieldTo2))
"""relField = obj.model._meta.get_field_by_name(fieldFrom)[0]\
.rel.to._meta.get_field_by_name(fieldTo1)[0]\
.rel.to._meta.get_field_by_name(fieldTo2)[0]"""
# 03/07/2013 : We get header name from fk verbose name and not linked to verbose name
relField = obj.model._meta.get_field_by_name(fieldFrom)[0]
if type(relField.verbose_name) == types.UnicodeType:
headerField = relField.verbose_name
else:
headerField = relField.name
logger.debug("jxDataQuery :: headerField: %s" % (headerField))
headers.append(headerField)
logger.debug("jxDataQuery :: headers: %s" % (headers))
results = {"headers": headers, "data": dataList, "meta": meta}
logger.debug("jxDataQuery :: results: %s" % (results))
return HttpResponse(json.dumps(results))
