def serialDoc(doc, nest_datagrid=True, serial_as='json'):
"""
Take a Plomino document :doc: and extract its data in a JSON-serializable
structure for printing porposes.
Item values are renderized according to the field definition and only
defined fields will be considered.
"""
# bad_items are indistinguishable from good behaved citizen: they are unicode values
# that just don't belong to the data (they are in fact metadata)
# We want to skip those, and to do that we must explicitly list 'em
bad_items = ['Plomino_Authors', 'Form']
res = []
form = doc.getForm()
for field in form.getFormFields(includesubforms=True, doc=None, applyhidewhen=False):
#for itemname in doc.getItems():
itemname = field.id
if itemname not in bad_items:
itemvalue = doc.getItem(itemname, '') or ''
fieldname = itemname
res += serialItem(form, fieldname, itemvalue, doc=doc, nest_datagrid=nest_datagrid)
if serial_as == 'json':
return json_dumps(dict(res))
elif serial_as == 'xml':
from dict2xml import dict2xml
return dict2xml(dict(res))
else:
return res
def render_as_dataTable(aaData, fieldid, params={}, rawparams=""):
'''
useful params examples:
oLanguage = {'sUrl': '/'.join(context.getParentDatabase().absolute_url().split('/')[:-1] + ['DataTables', 'getLanguagePat'])}
rawparams examples:
"""aoColumns = [
{ "sTitle": "N° Aut.", "mDataProp": "numero_autorizzazione" },
{ "sTitle": "Inizio validità", "mDataProp": "data_inizio_valido" },
{ "sTitle": "Fine validità", "mDataProp": "data_fine_valido" },
{ "mDataProp": "id", "fnRender": function (aaData, value) {return '<a href="../'+ value +'">'+ "vai all'autorizzazione" +'</a>'} }
]"""
Warning: rawparams code will be simply queued to other parameters, do not
use rawparams for passing paramters already in params or in default_params such as:
bJQueryUI, bPaginate, bLengthChange, bFilter, bSort, bInfo, bAutoWidth.
'''
# default Plomino dataTable parameters
defautl_params = {
'bJQueryUI': True,
'bPaginate': True,
'bLengthChange': True,
'bFilter': True,
'bSort': True,
'bInfo': True,
'bAutoWidth': False
}
defautl_params.update(params)
defautl_params = json_dumps(defautl_params)
if rawparams:
defautl_params = defautl_params[:-1] + ', %s' + '}'
defautl_params = defautl_params % rawparams
aaData = json_dumps(aaData)
html = """<script type="text/javascript" charset="utf-8">
var aaData = %(aaData)s;
var o_%(fieldid)s_DynamicTable;
jq(document).ready(function() {
o_%(fieldid)s_DynamicTable = jq('#%(fieldid)s_table').dataTable( {
'aaData': %(aaData)s,
%(default_params)s
} );
});
</script><table id='%(fieldid)s_table' class="display"></table><div style="clear: both"></div>""" % locals()
return html
def get_aaData(brain, field_names, sortindex, reverse, enum, linked, field_renderes):
aaData = []
for num,rec in enumerate(brain):
if enum:
row = [num+1]
else:
row = []
for k in field_names:
value = rec[k]
if not value:
value = ''
else:
if k in field_renderes:
value = field_renderes[k](value)
if linked:
value = '<a href="%(url)s">%(label)s</a>' % dict(url=rec.getURL(), label=json_dumps(value).replace('"', ''))
row.append(value)
rendered_value = '%s| ' % json_dumps(row)
if sortindex:
aaData.append((rec[sortindex], rendered_value, ))
else:
aaData.append(rendered_value)
if sortindex:
aaData.sort()
if reverse:
aaData.reverse()
if sortindex:
return [rec[-1] for rec in aaData]
else:
return aaData
def parseXML(text):
try:
import xmltodict
return json_loads(json_dumps((xmltodict.parse(text))))
except Exception as error:
return error
async def inventory_cmd(ctx, *args):
kw = {"event": None, "id": ctx.message.author.id, "quant": 0, "item": ""}
if len(args) == 0:
kw["event"] = "show"
elif args[0] == "?":
kw["event"] = "show"
if len(args) >= 2:
if args[1].isdecimal() and ctx.guild.get_member(int(args[1])):
kw["id"] = int(args[1])
if len(args) >= 3:
kw["item"] = " ".join(args[2:])
else:
kw["item"] = " ".join(args[1:])
elif args[0] == "-":
kw["event"] = "del"
if len(args) >= 2:
if args[1].isdecimal() and ctx.guild.get_member(int(args[1])):
kw["id"] = int(args[1])
if len(args) >= 3:
kw["item"] = " ".join(args[2:])
else:
kw["item"] = " ".join(args[1:])
elif re.search(r"^\s*[+\-]*\d+(\.\d+)*([Ee]\d+(\.\d+)*)*\s*$", args[0]):
kw["event"] = "add"
kw["quant"] = eval(args[0])
if len(args) >= 2:
kw["item"] = " ".join(args[1:])
else:
try:
await ctx.message.add_reaction("❗")
await asyncio.sleep(bot.timeout) if bot.timeout else None
await ctx.message.delete() if bot.timeout else None
except Exception as e:
bot.print(e)
return
args = bot.inv(**kw)
if args is False:
try:
await ctx.message.add_reaction("❗")
await asyncio.sleep(bot.timeout) if bot.timeout else None
await ctx.message.delete() if bot.timeout else None
except Exception as e:
bot.print(e)
return
if args[4]:
fmt = "{0.display_name} has {1} '{2}'"
args = ctx.message.author, args[3], args[4]
else:
fmt = "```json\n//Inventory for {0.display_name}\n{1}```"
args = ctx.message.author, json_dumps(args[0])
msg = await ctx.send(fmt.format(*args))
await del_or_pin(ctx.message, msg, 20.0)
await asyncio.sleep(bot.timeout) if bot.timeout else None
try:
await ctx.message.delete() if bot.timeout else None
except Exception:
pass
async def inventory(ctx, quant="?", *, item=None):
p = r"^\s*([+\-]*\d+(\.\d+)*([Ee][+\-]*\d+)*)|(\?)|(\-)\s*$"
p = re.search(p, quant)
if not p:
await ctx.message.add_reaction("❗")
bot.print("Bad value given to inventory command: '%s'" % quant)
return
fp = bot.rootfp + "/inv/" + str(ctx.message.author.id) + ".json"
if not os.path.exists(fp):
open(fp, "a+").close()
with open(fp, "r+") as data:
data.seek(0)
if not data.read():
data.write("{\n\n}")
data.truncate()
inv = json_load(fp, bot.print)
item = item.lower() if item is not None else None
if quant == "?":
if item is None:
out = "```json\n{}\n```".format(json_dumps(inv))
if len(out) > 2000:
out = out[:-10] + "\n...\n}```"
m = await ctx.send(out)
return await del_or_pin(ctx.message, m, 10.0)
inum = inv.get(item, 0)
elif quant == "-":
inv.pop(item, None)
with open(fp, "w") as data:
json_dump(inv, data)
else:
if ctx.guild.get_member(eval(quant)):
id = ctx.guild.get_member(eval(quant)).id
fp = bot.rootfp + "/inv/" + str(id) + ".json"
if not os.path.exists(fp):
open(fp, "a+").close()
with open(fp, "r+") as data:
data.seek(0)
if not data.read():
data.write("{\n\n}")
data.truncate()
inv = json_load(fp, bot.print)
out = "```json\n{}\n```".format(json_dumps(inv))
if len(out) > 2000:
out = out[:-10] + "\n...\n}```"
m = await ctx.send(out)
return await del_or_pin(ctx.message, m, 10.0)
elif item is None:
m = await ctx.send("`item is a required argument that is missing.`"
)
return await del_or_pin(ctx, m, 10.0)
else:
inum = eval(quant)
if float(inum).is_integer:
inum = int(inum)
inv[item] = inv.get(item, 0) + inum
with open(fp, "w") as data:
json_dump(inv, data)
inum = inv.get(item, 0)
if inum == 0 and item is None:
fmt = "{0.display_name} has nothing."
m = await ctx.send(fmt.format(ctx.message.author))
else:
fmt = "{0.display_name} has {1} '{2}'"
m = await ctx.send(fmt.format(ctx.message.author, inum, item))
await del_or_pin(ctx.message, m, 10.0)
def searchAndFetch(self, fields={}, mainRequest={}, sideRequests={}, json=False):
"""
dbsearch(self, request, sortindex, reverse=0)
mainRequest = dict(Form = <form_name>, **kwargs)
sideRequests = dict(
<form_name> = dict(**kwargs)
)
fields = dict(
<form_name> = [(<field_name>, <unique_name>, ), (<field_name>, ), ...]
...
)
"""
import itertools
if not 'Form' in mainRequest:
raise IOError('GISWEB.UTILS ERROR: A kay for the parent form is required!')
mainResults = self.idx.dbsearch(mainRequest)
# sideResults = dict(<parentId> = dict(<form_name> = [{**kwargs}, ...], ...))
sideResults = dict()
for form_name, sideRequest in sideRequests.items():
if 'Form' not in sideRequest:
sideRequest['Form'] = form_name
sideRequest[self.parentKey] = {'query': [i.id for i in mainResults], 'operator': 'or'}
sideResult = self.idx.dbsearch(sideRequest, sortindex=self.parentKey)
for sideRecord in sideResult:
tmp_dict = dict()
for i in fields.get(form_name, []):
try:
value = sideRecord[i[0]]
except:
value = sideRecord.getObject().getItem(i[0], '')
tmp_dict[i[-1]] = value
if sideRecord[self.parentKey] not in sideResults:
sideResults[sideRecord[self.parentKey]] = {form_name: [tmp_dict]}
else:
if form_name not in sideResults[sideRecord[self.parentKey]]:
sideResults[sideRecord[self.parentKey]][form_name] = [tmp_dict]
else:
sideResults[sideRecord[self.parentKey]][form_name].append(tmp_dict)
for rec in mainResults:
mainForm = rec.getObject().Form
tmp_dict = dict([(i[-1], rec.get(i[0]) or rec.getObject().getItem(i[0], '')) for i in fields.get(mainForm, [])])
if rec.id not in sideResults:
sideResults[rec.id] = {mainForm: [tmp_dict]}
else:
if mainForm not in sideResults[rec.id]:
sideResults[rec.id][mainForm] = [tmp_dict]
else:
sideResults[rec.id][mainForm].append(tmp_dict)
# sideResults2 = dict(<plominoId> = [[{**kwargs}, ...], ...], ...)
sideResults2 = dict()
for key,value in sideResults.items():
sideResults2[key] = [x for x in itertools.product(*sideResults[key].values())]
sideResults3 = dict()
for key,prod in sideResults2.items():
for lista in prod:
it = [i.items() for i in lista]
s = sum(it[1:], it[0])
v = dict([(key,v) for k,v in s])
if not key in sideResults3:
sideResults3[key] = [v]
else:
sideResults3[key].append(v)
it = []
for tt in prod:
mit = [i.items() for i in tt]
somma = sum(mit[1:], mit[0])
it.append(dict([(k,v) for k,v in somma]))
sideResults3[key] = it
aaData = []
for mainId,v in sideResults3.items():
mainDict = dict()
if mainRequest['Form'] in fields:
mainDoc = self.db.getDocument(mainId)
for x in fields[mainRequest['Form']]:
mainDict[x[-1]] = mainDoc.getItem(x[0], '')
for i in v:
it = i.items() + mainDict.items()
aaRecord = dict()
for key,value in it:
# if isinstance(value, Missing.Value): # to be tested
vtype = '%s' % type(value) # could be better to use isinstance for the test
if vtype == "<type 'Missing.Value'>":
value = None
aaRecord[key] = value
# aaRecord = dict([(key,value) for key,value in it])
if aaRecord:
aaData.append(aaRecord)
if json:
return json_dumps(aaData)
else:
return aaData
