def insert_sample_data():
import requests
from app.models import Document
url = 'https://api.github.com/users/moby/repos'
sample_data = json.loads(requests.get(url).content.decode('utf-8'))
for x in sample_data:
d = Document(doc=x)
d.create(d)
def post():
raw_dict = request.get_json(force=True)
try:
schema.validate(raw_dict)
doc_dict = raw_dict['data']['attributes']
doc = Document(doc=doc_dict['doc'])
doc.create(doc)
query = Document.query.get(doc.id)
result = schema.dump(query).data
return jsonify(result), 201
except ValidationError as ve:
response = jsonify({'code': 403, 'message': ve.messages})
return response, 403
except SQLAlchemyError as e:
db.session.rollback()
resp = jsonify({'code': 500, 'message': str(e)})
return response, 500
def export_user_data_in_word_task(self, created_by: int, request_data: dict, to_pdf: int):
def _write_docx_content(rows: list, document: docx.Document) -> None:
header_fields = rows[0]
assert len(header_fields) == len(_COLUMN_DISPLAY_ORDER)
table = document.add_table(rows=len(rows), cols=len(header_fields))
for i in range(len(rows)):
row = table.rows[i]
for j, table_cell in enumerate(rows[i]):
row.cells[j].text = str(table_cell)
self.update_state(state='PROGRESS', meta={
'current': i,
'total': self.total_progress,
'status': 'In progress...',
})
user_list = _get_user_data(request_data)
# Word table rows + 2 (Word table header and save data in database)
self.total_progress = len(user_list) + 2
tempfile_suffix = '.docx'
tempfile = NamedTemporaryFile(suffix=tempfile_suffix)
table_data = []
mime_type = PDF_MIME_TYPE if to_pdf else MS_WORD_MIME_TYPE
self.update_state(state='PROGRESS', meta={
'current': 0,
'total': self.total_progress,
'status': 'In progress...',
})
_add_table_column_names(table_data, set(_COLUMN_DISPLAY_ORDER))
_add_table_user_data(user_list, table_data)
document = docx.Document()
_write_docx_content(table_data, document)
document.save(tempfile.name)
directory_path = current_app.config.get('STORAGE_DIRECTORY')
temp_filename = FileStorage.get_basename(tempfile.name, include_path=False)
if to_pdf:
convert_to(directory_path, tempfile.name)
else:
dst = f'{directory_path}/{temp_filename}{tempfile_suffix}'
FileStorage.copy_file(tempfile.name, dst)
file_extension = mimetypes.guess_extension(mime_type)
internal_filename = '%s%s' % (uuid.uuid1().hex, file_extension)
filepath = '%s/%s' % (directory_path, internal_filename)
try:
file_prefix = datetime.utcnow().strftime('%Y%m%d')
basename = f'{file_prefix}_users'
filename = f'{basename}{file_extension}'
src = '%s/%s%s' % (directory_path, temp_filename, file_extension)
FileStorage.rename(src, filepath)
data = {
'created_by': created_by,
'name': filename,
'internal_filename': internal_filename,
'mime_type': mime_type,
'directory_path': directory_path,
'size': FileStorage.get_filesize(filepath),
}
document = DocumentModel.create(**data)
except Exception as e:
if os.path.exists(filepath):
os.remove(filepath)
logger.debug(e)
raise e
document_serializer = DocumentSerializer(exclude=('internal_filename',))
document_data = document_serializer.dump(document)
return {
'current': self.total_progress,
'total': self.total_progress,
'status': 'Task completed!',
'result': document_data,
}
def export_user_data_in_excel_task(self, created_by: int, request_data: dict):
def _write_excel_rows(rows: list, workbook: Workbook,
worksheet: Worksheet) -> int:
excel_longest_word = ''
for i, row in enumerate(rows, 1):
row_format = None
if i == 1:
row_format = workbook.add_format({
'bold': True,
'bg_color': '#cccccc',
})
elif i % 2 == 0:
row_format = workbook.add_format({
'bg_color': '#f1f1f1',
})
range_cells = 'A%s:I10' % i
row_longest_word = find_longest_word(row)
if len(row_longest_word) > len(excel_longest_word):
excel_longest_word = row_longest_word
worksheet.write_row(range_cells, row, row_format)
self.update_state(state='PROGRESS',
meta={
'current': i,
'total': self.total_progress,
'status': 'In progress...',
})
return len(excel_longest_word)
user_list = _get_user_data(request_data)
# Excel rows + 2 (Excel header row and save data in database)
self.total_progress = len(user_list) + 2
tempfile = NamedTemporaryFile()
excel_rows = []
self.update_state(state='PROGRESS',
meta={
'current': 0,
'total': self.total_progress,
'status': 'In progress...',
})
workbook = xlsxwriter.Workbook(tempfile.name)
worksheet = workbook.add_worksheet()
worksheet.set_zoom(120)
_get_excel_column_names(excel_rows)
_get_excel_user_data(user_list, excel_rows)
_add_excel_autofilter(worksheet)
excel_longest_word = _write_excel_rows(excel_rows, workbook, worksheet)
_adjust_each_column_width(excel_rows, worksheet, excel_longest_word)
workbook.close()
filepath = ''
try:
mime_type = magic.from_file(tempfile.name, mime=True)
file_extension = mimetypes.guess_extension(mime_type)
internal_filename = '%s%s' % (uuid.uuid1().hex, file_extension)
directory_path = current_app.config.get('STORAGE_DIRECTORY')
filepath = f'{directory_path}/{internal_filename}'
data = tempfile.file.read()
fs = FileStorage()
fs.save_bytes(data, filepath)
file_prefix = datetime.utcnow().strftime('%Y%m%d')
basename = f'{file_prefix}_users'
filename = f'{basename}{file_extension}'
data = {
'created_by': created_by,
'name': filename,
'internal_filename': internal_filename,
'mime_type': mime_type,
'directory_path': directory_path,
'size': fs.get_filesize(filepath),
}
document = DocumentModel.create(**data)
except Exception:
if os.path.exists(filepath):
os.remove(filepath)
raise
document_serializer = DocumentSerializer(exclude=('internal_filename', ))
document_data = document_serializer.dump(document)
return {
'current': self.total_progress,
'total': self.total_progress,
'status': 'Task completed!',
'result': document_data,
}
