def formdefs(request, domain, app_id):
# TODO: Looks like this function is never used
langs = [json.loads(request.GET.get('lang', '"en"'))]
format = request.GET.get('format', 'json')
app = get_app(domain, app_id)
def get_questions(form):
xform = XForm(form.source)
prefix = '/%s/' % xform.data_node.tag_name
def remove_prefix(string):
if string.startswith(prefix):
return string[len(prefix):]
else:
raise Exception()
def transform_question(q):
return {
'id': remove_prefix(q['value']),
'type': q['tag'],
'text': q['label'] if q['tag'] != 'hidden' else ''
}
return [transform_question(q) for q in xform.get_questions(langs)]
formdefs = [{
'name':
"%s, %s" % (f['form'].get_module().name['en'], f['form'].name['en'])
if f['type'] == 'module_form' else 'User Registration',
'columns': ['id', 'type', 'text'],
'rows':
get_questions(f['form'])
} for f in app.get_forms(bare=False)]
if format == 'xlsx':
f = StringIO()
writer = Excel2007ExportWriter()
writer.open([(sheet['name'], [FormattedRow(sheet['columns'])])
for sheet in formdefs], f)
writer.write([(sheet['name'], [
FormattedRow([
cell for (_, cell) in sorted(
row.items(),
key=lambda item: sheet['columns'].index(item[0]))
]) for row in sheet['rows']
]) for sheet in formdefs])
writer.close()
response = HttpResponse(
f.getvalue(), content_type=Format.from_format('xlsx').mimetype)
set_file_download(response, 'formdefs.xlsx')
return response
else:
return json_response(formdefs)
def trim(self, data, doc, apply_transforms, global_transform):
from couchexport.export import FormattedRow, Constant, transform_error_constant
if not hasattr(self, '_headers'):
self._headers = tuple(data[0].get_data())
# skip first element without copying
data = islice(data, 1, None)
rows = []
for row in data:
id = None
cells = []
for column, val in self.get_items_in_order(row):
# TRANSFORM BABY!
if apply_transforms:
if column.transform and not isinstance(val, Constant):
try:
val = column.transform(val, doc)
except Exception:
val = transform_error_constant
elif global_transform:
val = global_transform(val, doc)
if column.index == 'id':
id = val
else:
cells.append(val)
id_index = self.id_index if id else 0
row_id = row.id if id else None
rows.append(FormattedRow(cells, row_id, id_index=id_index))
return rows
def write(self, table, row):
"""
Write the given row to the given table of the export.
_Writer must be opened first.
:param table: A TableConfiguration
:param row: An ExportRow
"""
return self.writer.write([(table, [FormattedRow(data=row.data)])])
def generate_bulk_file(self, update_progress=None):
update_progress = update_progress or (lambda x: x)
configs = list()
schemas = list()
checkpoints = list()
for export_object in self.export_objects:
config, schema, checkpoint = export_object.get_export_components(
filter=self.export_filter)
configs.append(config)
schemas.append(schema)
checkpoints.append(checkpoint)
writer = get_writer(self.format)
# generate the headers for the bulk excel file
headers = self.generate_table_headers(schemas, checkpoints)
fd, path = tempfile.mkstemp()
with os.fdopen(fd, 'wb') as tmp:
writer.open(headers, tmp)
# now that the headers are set, lets build the rows
for i, config in enumerate(configs):
try:
for doc in config.get_docs():
if self.export_objects[i].transform:
doc = self.export_objects[i].transform(doc)
table = get_formatted_rows(doc,
schemas[i],
separator=self.separator,
include_headers=isinstance(
self, CustomBulkExport))
if isinstance(self, CustomBulkExport):
table = self.export_objects[i].trim(table, doc)
if table and table[0]:
# if an export only contains data from repeats and a form has no repeats
# then the table list will be empty
table = self.export_objects[i].parse_tables(table)
writer.write(table)
except SchemaMismatchException:
# fire off a delayed force update to prevent this from happening again
rebuild_schemas.delay(self.export_objects[i].index)
writer.write([(self.export_objects[i].table_name, [
FormattedRow([
ugettext(
'There was an error generating this export. '
'If the problem persists please report an issue.'
)
],
separator=self.separator)
])])
update_progress(i + 1)
writer.close()
return path
def write(self, table, row):
"""
Write the given row to the given table of the export.
_Writer must be opened first.
:param table: A TableConfiguration
:param row: An ExportRow
"""
return self.writer.write([(table, [
FormattedRow(data=row.data,
hyperlink_column_indices=row.hyperlink_column_indices,
skip_excel_formatting=row.skip_excel_formatting
if hasattr(row, 'skip_excel_formatting') else ())
])])
def write(self, table, row):
"""
Write the given row to the given table of the export.
Will automatically open a new table and write to that if it
has exceeded the number of rows written in the first table.
:param table: A TableConfiguration
:param row: An ExportRow
"""
if self.rows_written[table] >= self.page_length * (self.pages[table] + 1):
self.pages[table] += 1
self.writer.add_table(
self._paged_table_index(table),
self._get_paginated_headers()[self._paged_table_index(table)][0],
table_title=self._get_paginated_table_titles()[self._paged_table_index(table)],
)
self.writer.write([(self._paged_table_index(table), [FormattedRow(data=row.data)])])
self.rows_written[table] += 1
def get_headers_row(self):
from couchexport.export import FormattedRow
headers = []
for col in self.columns:
if issubclass(type(col), ComplexExportColumn):
for header in col.get_headers():
headers.append(header)
else:
display = col.get_display()
if col.index == 'id':
id_len = len([
part for part in self.index.split('.') if part == '#'
])
headers.append(display)
if id_len > 1:
for i in range(id_len):
headers.append('{id}__{i}'.format(id=display, i=i))
else:
headers.append(display)
return FormattedRow(headers)