def update_custom_export(self):
"""
Updates custom_export object from the request
and saves to the db
"""
post_data = self.post_data
custom_export_json = post_data['custom_export']
if post_data['presave'] and not self.allow_daily_saved:
raise BadExportConfiguration(_("This user does not have permission to create Daily Saved Exports"))
if custom_export_json['default_format'] == "html" and not self.allow_excel_dashboard:
raise BadExportConfiguration(_("This user does not have permission to create an excel dashboard"))
if custom_export_json["is_safe"] and not self.allow_deid:
raise BadExportConfiguration(_("This user does not have permission to create a de-identified export"))
SAFE_KEYS = ('default_format', 'is_safe', 'name', 'schema_id', 'transform_dates')
for key in SAFE_KEYS:
self.custom_export[key] = custom_export_json[key]
# update the custom export index (to stay in sync)
schema_id = self.custom_export.schema_id
schema = ExportSchema.get(schema_id)
self.custom_export.index = schema.index
self.presave = post_data['presave']
self.export_stock = post_data['export_stock']
self.custom_export.tables = [
ExportTable.wrap(table)
for table in custom_export_json['tables']
]
table_dict = dict((t.index, t) for t in self.custom_export.tables)
for table in self.custom_export.tables:
if table.index in table_dict:
table_dict[table.index].columns = table.columns
else:
self.custom_export.tables.append(
ExportTable(
index=table.index,
display=self.custom_export.name,
columns=table.columns
)
)
self.update_custom_params()
self.custom_export.custom_validate()
self.custom_export.save()
touch_exports(self.domain)
if self.presave:
HQGroupExportConfiguration.add_custom_export(self.domain, self.custom_export.get_id)
else:
HQGroupExportConfiguration.remove_custom_export(self.domain, self.custom_export.get_id)
return self.custom_export.get_id
def update_custom_export(self):
"""
Updates custom_export object from the request
and saves to the db
"""
post_data = self.post_data
custom_export_json = post_data['custom_export']
if post_data['presave'] and not self.allow_daily_saved:
raise BadExportConfiguration(_("This user does not have permission to create Daily Saved Exports"))
if custom_export_json['default_format'] == "html" and not self.allow_excel_dashboard:
raise BadExportConfiguration(_("This user does not have permission to create an excel dashboard"))
if custom_export_json["is_safe"] and not self.allow_deid:
raise BadExportConfiguration(_("This user does not have permission to create a de-identified export"))
SAFE_KEYS = ('default_format', 'is_safe', 'name', 'schema_id', 'transform_dates')
for key in SAFE_KEYS:
self.custom_export[key] = custom_export_json[key]
# update the custom export index (to stay in sync)
schema_id = self.custom_export.schema_id
schema = ExportSchema.get(schema_id)
self.custom_export.index = schema.index
self.presave = post_data['presave']
self.export_stock = post_data['export_stock']
self.custom_export.tables = [
ExportTable.wrap(table)
for table in custom_export_json['tables']
]
table_dict = dict((t.index, t) for t in self.custom_export.tables)
for table in self.custom_export.tables:
if table.index in table_dict:
table_dict[table.index].columns = table.columns
else:
self.custom_export.tables.append(
ExportTable(
index=table.index,
display=self.custom_export.name,
columns=table.columns
)
)
self.update_custom_params()
self.custom_export.custom_validate()
self.custom_export.save()
touch_exports(self.domain)
if self.presave:
HQGroupExportConfiguration.add_custom_export(self.domain, self.custom_export.get_id)
else:
HQGroupExportConfiguration.remove_custom_export(self.domain, self.custom_export.get_id)
return self.custom_export.get_id
def update_custom_export(self):
"""
Updates custom_export object from the request
and saves to the db
"""
schema = ExportSchema.get(self.request.POST["schema"])
self.custom_export.index = schema.index
self.custom_export.schema_id = self.request.POST["schema"]
self.custom_export.name = self.request.POST["name"]
self.custom_export.default_format = self.request.POST["format"] or Format.XLS_2007
self.custom_export.is_safe = bool(self.request.POST.get('is_safe'))
self.presave = bool(self.request.POST.get('presave'))
table = self.request.POST["table"]
cols = self.request.POST['order'].strip().split()
@list
@inline
def export_cols():
for col in cols:
transform = self.request.POST.get('%s transform' % col) or None
if transform:
transform = SerializableFunction.loads(transform)
yield ExportColumn(
index=col,
display=self.request.POST["%s display" % col],
transform=transform
)
export_table = ExportTable(index=table, display=self.request.POST["name"], columns=export_cols)
self.custom_export.tables = [export_table]
self.custom_export.order = cols
table_dict = dict([t.index, t] for t in self.custom_export.tables)
if table in table_dict:
table_dict[table].columns = export_cols
else:
self.custom_export.tables.append(ExportTable(index=table,
display=self.custom_export.name,
columns=export_cols))
if self.export_type == 'form':
self.custom_export.include_errors = bool(self.request.POST.get("include-errors"))
self.custom_export.app_id = self.request.POST.get('app_id')
self.custom_export.save()
if self.presave:
HQGroupExportConfiguration.add_custom_export(self.domain, self.custom_export.get_id)
else:
HQGroupExportConfiguration.remove_custom_export(self.domain, self.custom_export.get_id)
def testSaveAndLoad(self):
index = ["foo", 2]
schema = ExportSchema(seq=5, index=index)
inner = {"dict": {"bar": 1, "baz": [2,3]},
"list": ["foo", "bar"],
"dictlist": [{"bip": 1, "bop": "blah"},
{"bip": 2, "bop": "blah2"}],
"item": "yoyoyo"}
schema.schema = inner
schema.save()
back = ExportSchema.get(schema.get_id)
self.assertEqual(inner, back.schema)
self.assertEqual(index, back.index)
def testSaveAndLoad(self):
index = ["foo", 2]
schema = ExportSchema(seq="5", index=index, timestamp=datetime.now())
inner = {"dict": {"bar": 1, "baz": [2,3]},
"list": ["foo", "bar"],
"dictlist": [{"bip": 1, "bop": "blah"},
{"bip": 2, "bop": "blah2"}],
"item": "yoyoyo"}
schema.schema = inner
schema.save()
back = ExportSchema.get(schema.get_id)
self.assertEqual(inner, back.schema)
self.assertEqual(index, back.index)
def update_custom_export(self):
"""
Updates custom_export object from the request
and saves to the db
"""
post_data = self.post_data
custom_export_json = post_data['custom_export']
SAFE_KEYS = ('default_format', 'is_safe', 'name', 'schema_id', 'transform_dates')
for key in SAFE_KEYS:
self.custom_export[key] = custom_export_json[key]
# update the custom export index (to stay in sync)
schema_id = self.custom_export.schema_id
schema = ExportSchema.get(schema_id)
self.custom_export.index = schema.index
self.presave = post_data['presave']
self.export_stock = post_data['export_stock']
self.custom_export.tables = [
ExportTable.wrap(table)
for table in custom_export_json['tables']
]
table_dict = dict((t.index, t) for t in self.custom_export.tables)
for table in self.custom_export.tables:
if table.index in table_dict:
table_dict[table.index].columns = table.columns
else:
self.custom_export.tables.append(
ExportTable(
index=table.index,
display=self.custom_export.name,
columns=table.columns
)
)
self.update_custom_params()
self.custom_export.custom_validate()
self.custom_export.save()
touch_exports(self.domain)
if self.presave:
HQGroupExportConfiguration.add_custom_export(self.domain, self.custom_export.get_id)
else:
HQGroupExportConfiguration.remove_custom_export(self.domain, self.custom_export.get_id)
return self.custom_export.get_id
def update_custom_export(self):
"""
Updates custom_export object from the request
and saves to the db
"""
post_data = self.post_data
custom_export_json = post_data['custom_export']
SAFE_KEYS = ('default_format', 'is_safe', 'name', 'schema_id', 'transform_dates')
for key in SAFE_KEYS:
self.custom_export[key] = custom_export_json[key]
# update the custom export index (to stay in sync)
schema_id = self.custom_export.schema_id
schema = ExportSchema.get(schema_id)
self.custom_export.index = schema.index
self.presave = post_data['presave']
self.export_stock = post_data['export_stock']
self.custom_export.tables = [
ExportTable.wrap(table)
for table in custom_export_json['tables']
]
table_dict = dict((t.index, t) for t in self.custom_export.tables)
for table in self.custom_export.tables:
if table.index in table_dict:
table_dict[table.index].columns = table.columns
else:
self.custom_export.tables.append(
ExportTable(
index=table.index,
display=self.custom_export.name,
columns=table.columns
)
)
self.update_custom_params()
self.custom_export.custom_validate()
self.custom_export.save()
touch_exports(self.domain)
if self.presave:
HQGroupExportConfiguration.add_custom_export(self.domain, self.custom_export.get_id)
else:
HQGroupExportConfiguration.remove_custom_export(self.domain, self.custom_export.get_id)
return self.custom_export.get_id
def testExportTokenMigration(self):
c = Client()
c.login(**{'username': '******', 'password': '******'})
submit_form()
time.sleep(1)
resp = get_export_response(c)
self.assertEqual(200, resp.status_code)
self.assertTrue(resp.content is not None)
self.assertTrue("X-CommCareHQ-Export-Token" in resp)
# blow away the timestamp property to ensure we're testing the
# migration case
prev_token = resp["X-CommCareHQ-Export-Token"]
prev_checkpoint = ExportSchema.get(prev_token)
assert prev_checkpoint.timestamp
prev_checkpoint.timestamp = None
prev_checkpoint.save()
prev_checkpoint = ExportSchema.get(prev_token)
assert not prev_checkpoint.timestamp
# data but no new data = redirect
resp = get_export_response(c, prev_token)
self.assertEqual(302, resp.status_code)
submit_form()
time.sleep(1)
resp = get_export_response(c, prev_token)
self.assertEqual(200, resp.status_code)
self.assertTrue(resp.content is not None)
self.assertTrue("X-CommCareHQ-Export-Token" in resp)
prev_token = resp["X-CommCareHQ-Export-Token"]
full_data = get_export_response(c).content
partial_data = get_export_response(c, prev_token).content
self.assertTrue(len(full_data) > len(partial_data))
def testExportTokenMigration(self):
c = Client()
c.login(**{'username': '******', 'password': '******'})
_submit_form()
time.sleep(1)
resp = get_export_response(c)
self.assertEqual(200, resp.status_code)
self.assertTrue(_content(resp) is not None)
self.assertTrue("X-CommCareHQ-Export-Token" in resp)
# blow away the timestamp property to ensure we're testing the
# migration case
prev_token = resp["X-CommCareHQ-Export-Token"]
prev_checkpoint = ExportSchema.get(prev_token)
assert prev_checkpoint.timestamp
def testExportTokenMigration(self):
c = Client()
c.login(**{'username': '******', 'password': '******'})
self._submit_form()
time.sleep(1)
resp = get_export_response(c)
self.assertEqual(200, resp.status_code)
self.assertTrue(_content(resp) is not None)
self.assertTrue("X-CommCareHQ-Export-Token" in resp)
# blow away the timestamp property to ensure we're testing the
# migration case
prev_token = resp["X-CommCareHQ-Export-Token"]
prev_checkpoint = ExportSchema.get(prev_token)
assert prev_checkpoint.timestamp
def get_export_components(schema_index, previous_export_id=None, filter=None):
"""
Get all the components needed to build an export file.
"""
previous_export = ExportSchema.get(previous_export_id) if previous_export_id else None
database = get_db()
config = ExportConfiguration(database, schema_index, previous_export, filter)
# handle empty case
if not config.potentially_relevant_ids:
return None, None, None
# get and checkpoint the latest schema
updated_schema = config.get_latest_schema()
export_schema_checkpoint = config.create_new_checkpoint()
return config, updated_schema, export_schema_checkpoint
def get_export_components(schema_index, previous_export_id=None, filter=None):
"""
Get all the components needed to build an export file.
"""
previous_export = ExportSchema.get(previous_export_id)\
if previous_export_id else None
database = get_db()
config = ExportConfiguration(database, schema_index, previous_export,
filter)
# handle empty case
if not config.potentially_relevant_ids:
return None, None, None
# get and checkpoint the latest schema
updated_schema = config.get_latest_schema()
export_schema_checkpoint = config.create_new_checkpoint()
return config, updated_schema, export_schema_checkpoint
def export(
schema_index,
file,
format=Format.XLS_2007,
previous_export_id=None,
filter=None,
max_column_size=2000,
separator="|",
):
"""
Exports data from couch documents matching a given tag to a file.
Returns true if it finds data, otherwise nothing
"""
previous_export = ExportSchema.get(previous_export_id) if previous_export_id else None
database = get_db()
config = ExportConfiguration(database, schema_index, previous_export, filter)
# handle empty case
if not config.potentially_relevant_ids:
return None
# get and checkpoint the latest schema
updated_schema = get_schema_new(config)
export_schema_checkpoint = ExportSchema(seq=config.current_seq, schema=updated_schema, index=config.schema_index)
export_schema_checkpoint.save()
# transform docs onto output and save
writer = get_writer(format)
# open the doc and the headers
formatted_headers = get_headers(updated_schema, separator=separator)
writer.open(formatted_headers, file)
for doc in config.get_docs():
writer.write(
format_tables(create_intermediate_tables(doc, updated_schema), include_headers=False, separator=separator)
)
writer.close()
return export_schema_checkpoint