def test_05(self):
ss = SpreadSheet()
ss.read(self.file, reader_args={'ignore_sheets': u'Empty'})
self.assertEqual(
ss.names, [u'List', u'Formulas', u'Participants'])
def download_selected(self, queryset, writer_type, sheet_mapping=None):
""" Generates sheet from queryset for downloading.
:param writer_type: Sheet writer short name.
"""
if sheet_mapping is None:
if hasattr(self, 'sheet_mapping'):
sheet_mapping = self.sheet_mapping
else:
sheet_mapping = [
(
column.replace(u'__', u':'),
column.split(u'__'))
for column in self.list_display[1:]
]
try:
writer = SheetWriter.plugins[writer_type]
data = self.dump_query_to_sheet(queryset, sheet_mapping)
except KeyError:
writer = SpreadSheetWriter.plugins[writer_type]
data = SpreadSheet()
sheet = data.create_sheet(u'Duomenys')
self.dump_query_to_sheet(queryset, sheet_mapping, sheet)
response = HttpResponse(content_type=writer.mime_type)
response['Content-Disposition'] = (
_(u'attachment; filename=data.{0}').format(
writer.file_extensions[0]))
data.write(response, writer=writer())
return response
def test_01(self):
ss = SpreadSheet()
self.assertEqual(ss.names, [])
self.assertEqual(len(ss), 0)
sheet1 = ss.create_sheet(u'sheet1')
self.assertEqual(ss.names, [u'sheet1'])
self.assertEqual(len(ss), 1)
self.assertEqual(list(ss), [sheet1])
self.assertIs(sheet1.spreadsheet, ss)
self.assertEqual(sheet1.name, u'sheet1')
self.assertIs(ss[u'sheet1'], sheet1)
del ss[u'sheet1']
self.assertIs(sheet1.name, None)
self.assertIs(sheet1.spreadsheet, None)
def generate_spreadsheet(self, klass, sheet_mapping, data):
""" Generates spreadsheet.
"""
mapping = []
mapping_dict = {}
captions = []
related = set()
for caption, parts in sheet_mapping:
captions.append(caption)
mapping.append((caption, parts))
mapping_dict[caption] = parts
if len(parts) > 1:
related.add(u'__'.join(parts[:-1]))
spreadsheet = SpreadSheet()
make_provided = lambda x: x + u' (provided)'
for sheet in data:
keys = set(sheet.captions) & set(captions)
provided_captions = [
make_provided(caption) for caption in sheet.captions]
new_sheet = spreadsheet.create_sheet(
sheet.name,
captions=provided_captions + captions)
fill_columns = len(captions)
for row in sheet:
query = dict(
(u'__'.join(mapping_dict[key]), row[key])
for key in keys
)
try:
obj = klass.objects.get(**query)
except Exception as e:
new_sheet.append_iterable(
list(row) +
[_(u'Error: {0}').format(e)] * fill_columns)
else:
info = dict(
(make_provided(key), row[key])
for key in row.keys())
for caption, field in mapping:
info[caption] = unicode(
get_field_value(obj, field))
new_sheet.append_dict(info)
return spreadsheet
def test_02(self):
ss = SpreadSheet(
names=[u'sheet1', u'sheet2'], sheet_captions=[u'GID'])
ss.add_validator(integer_gid, 'insert_row', 'replace_row')
row_validator = UniqueIntegerValidator2(u'GID')
ss.add_validator(row_validator.insert, 'insert_row')
ss.add_validator(row_validator.delete, 'delete_row')
ss.add_validator(row_validator.replace, 'replace_row')
sheet1 = ss[u'sheet1']
sheet2 = ss[u'sheet2']
sheet1.append([1])
sheet1.append([2])
self.assertRaises(ValidationError, sheet1.append, [2])
self.assertRaises(ValidationError, sheet2.append, [2])
del sheet1[1]
sheet2.append([2])
self.assertRaises(ValidationError, sheet1.append, [2])
sheet2[0] = {u'GID': 3}
sheet1.append([2])
def download_query(queryset, writer_type, **kwargs):
""" Generates sheet from queryset for downloading.
:param writer_type: Sheet writer short name.
"""
try:
writer = SheetWriter.plugins[writer_type]
data = dump_query_to_sheet(queryset, **kwargs)
except KeyError:
writer = SpreadSheetWriter.plugins[writer_type]
data = SpreadSheet()
sheet = data.create_sheet(u'Duomenys')
dump_query_to_sheet(queryset, sheet, **kwargs)
response = HttpResponse(mimetype=writer.mime_type)
response['Content-Disposition'] = (
'attachment; filename=duomenys.{0}'.format(
writer.file_extensions[0]))
data.write(response, writer=writer())
return response
def test_01(self):
ss = SpreadSheet(names=[u'sheet1', u'sheet2'])
self.assertEqual(len(ss), 2)
self.assertRaises(IntegrityError, ss.create_sheet, u'sheet1')
validator = SheetOrder()
ss.add_validator(validator.add, 'add_sheet')
ss.add_validator(validator.remove, 'remove_sheet')
self.assertRaises(ValueError, ss.create_sheet, u'sheet3')
self.assertEqual(len(ss), 2)
ss.create_sheet(u' 1 ')
ss.create_sheet(u' 2 ')
self.assertRaises(ValidationError, ss.create_sheet, u' 1 ')
self.assertRaises(ValueError, ss.__delitem__, u'sheet1')
self.assertRaises(ValidationError, ss.__delitem__, u'1')
del ss[u'2']
def test_02(self):
ss = SpreadSheet()
sheet1 = ss.create_sheet(u'sheet1')
self.assertEqual(sheet1.insert_validators, [])
self.assertEqual(sheet1.delete_validators, [])
self.assertEqual(sheet1.replace_validators, [])
ss.add_sheet_validator_creator(unique_integer_validator_creator)
ss.add_sheet_validator(
validate_nothing, 'insert', 'delete', 'replace')
sheet2 = ss.create_sheet(u'sheet2')
v1, v2 = sheet1.insert_validators
self.assertIs(v2, validate_nothing)
self.assertEqual(
unicode(v1)[:91],
u'<bound method UniqueIntegerValidator.insert of '
u'<validators.UniqueIntegerValidator object at')
v1, v2 = sheet1.delete_validators
self.assertIs(v2, validate_nothing)
self.assertEqual(
unicode(v1)[:91],
u'<bound method UniqueIntegerValidator.delete of '
u'<validators.UniqueIntegerValidator object at')
v1, v2 = sheet1.replace_validators
self.assertIs(v2, validate_nothing)
self.assertEqual(
unicode(v1)[:92],
u'<bound method UniqueIntegerValidator.replace of '
u'<validators.UniqueIntegerValidator object at')
v1, v2 = sheet2.insert_validators
self.assertIs(v2, validate_nothing)
self.assertEqual(
unicode(v1)[:91],
u'<bound method UniqueIntegerValidator.insert of '
u'<validators.UniqueIntegerValidator object at')
v1, v2 = sheet2.delete_validators
self.assertIs(v2, validate_nothing)
self.assertEqual(
unicode(v1)[:91],
u'<bound method UniqueIntegerValidator.delete of '
u'<validators.UniqueIntegerValidator object at')
v1, v2 = sheet2.replace_validators
self.assertIs(v2, validate_nothing)
self.assertEqual(
unicode(v1)[:92],
u'<bound method UniqueIntegerValidator.replace of '
u'<validators.UniqueIntegerValidator object at')
sheet1.add_column(u'ID')
sheet1.append([1])
sheet1.append([2])
self.assertRaises(ValidationError, sheet1.append, [2])
sheet2.add_column(u'ID')
sheet2.append([2])
sheet1[1] = {u'ID': 3}
sheet1.append([2])
del sheet1[1]
self.assertEqual([row[u'ID'] for row in sheet1], [1, 2])
self.assertEqual([row[u'ID'] for row in sheet2], [2])
