def generate_all_document(self, field_values):
all_templates = self.template_service.get_templates_by_company(self.company)
for template in all_templates:
content = template.content
upload = template.upload
if upload:
# Template with upload mode
content = ''
elif content:
# Template with content mode
content = self.template_service.populate_content_with_field_values(content, field_values)
else:
# We cannot find the proper template, skip
continue
doc_name = "{} for employee".format(template.name)
# Create a new document based on type
doc = Document(company_id=self.company.id,
user_id=self.user.id,
name=doc_name,
content=content,
upload=upload,
signature=None)
doc.save()
def document_store():
form = DocumentCreateForm(request.form)
if form.validate():
document = Document()
document.create(data=form.data)
return Success(message="操作成功！")
return Fail(message=form.first_error)
def post(self, request, pk, format=None):
company_id = pk
name = request.DATA['document_name']
template_id = request.DATA['template_id']
signature = None
content = ''
template = self._get_template(template_id)
upload = template.upload
if (not name or not upload):
return Response(status.HTTP_400_BAD_REQUEST)
result_data = []
employees = CompanyUser.objects.filter(company=company_id, company_user_type=USER_TYPE_EMPLOYEE)
for employee in employees:
d = Document(company_id=company_id,
user_id=employee.user.id,
name=name,
signature=signature,
content=content,
upload_id=upload.id)
d.save()
serializer = DocumentSerializer(d)
result_data.append(serializer.data)
return Response(result_data, status=status.HTTP_201_CREATED)
def process_csv(self):
uploads = self.components.upload.get_uploads()
csv_file = uploads['file'][0] # only one file should be uploaded
if csv_file.content_type in ['text/csv', 'application/vnd.ms-excel']:
Document.import_document(csv_file)
return_value = "File Uploaded Successfully. Check your Task Queue inthe Google App Engine Control Panel"
else:
print csv_file.content_type
return_value = 'The file provided is not of type ''text/csv'' or ''application/vnd.ms-excel'''
return return_value
def test_get_document_data(client: CustomFlaskClient, auth_header: any):
document = (DocumentModel.select().where(
DocumentModel.deleted_at.is_null()).order_by(
fn.Random()).limit(1).get())
db_wrapper.database.close()
document_id = document.id
response = client.get(f'/api/documents/{document_id}',
json={},
headers=auth_header())
json_response = response.get_json()
json_data = json_response.get('data')
parse_url = urlparse(json_data.get('url'))
assert 200 == response.status_code
assert document.created_by.id == json_data.get('created_by').get('id')
assert document.name == json_data.get('name')
assert document.mime_type == json_data.get('mime_type')
assert document.size == json_data.get('size')
assert parse_url.scheme and parse_url.netloc
assert document.created_at.strftime('%Y-%m-%d %H:%M:%S') == json_data.get(
'created_at')
assert document.updated_at.strftime('%Y-%m-%d %H:%M:%S') == json_data.get(
'updated_at')
assert document.deleted_at == json_data.get('deleted_at')
def test_update_document(client: CustomFlaskClient, auth_header: any):
pdf_file = '%s/example.pdf' % current_app.config.get('MOCKUP_DIRECTORY')
document = (DocumentModel.select().where(
DocumentModel.deleted_at.is_null()).order_by(
fn.Random()).limit(1).get())
db_wrapper.database.close()
document_id = document.id
data = {
'document': open(pdf_file, 'rb'),
}
headers = auth_header()
headers['Content-Type'] = 'multipart/form-data'
response = client.put(f'/api/documents/{document_id}',
data=data,
headers=headers)
json_response = response.get_json()
json_data = json_response.get('data')
parse_url = urlparse(json_data.get('url'))
assert 200 == response.status_code
assert isinstance(json_data.get('created_by').get('id'), int)
assert pdf_file == json_data.get('name')
assert document.mime_type == json_data.get('mime_type')
assert FileStorage.get_filesize(pdf_file) == json_data.get('size')
assert parse_url.scheme and parse_url.netloc
assert document.created_at.strftime('%Y-%m-%d %H:%M:%S') == json_data.get(
'created_at')
assert json_data.get('updated_at') > json_data.get('created_at')
assert json_data.get('deleted_at') is None
def document_edit(id):
document = Document.get_by_id(id)
columns = Column.get_all_for_select(is_group=True)
attribute = document.attribute.split(',')
return render_template('admin/document/edit.html',
document=document,
columns=columns,
attribute=attribute)
def extract(self, infile):
"""Extract ``Document``\s from a ``DocumentFile``. This method uses the
structure_file given in the constructor for rules to identify
``Document``\s.
:param str infile: The path to the file to extract.
:return list of DocumentFiles: The DocumentFile that contains the
extracted documents.
"""
documents = []
# Check for unescaped special characters (tentative)
doc = None
try:
doc = etree.parse(infile)
except(etree.XMLSyntaxError) as e:
self.project_logger.error("XML Error: %s; skipping file", str(e))
self.project_logger.info(infile)
return documents
extracted_units = self.extract_unit_information(self.document_structure,
doc)
#TODO: this doc_num isn't very helpful
doc_num = 0
try:
document_file = DocumentFile.query.filter(
DocumentFile.path == infile
).one()
except NoResultFound:
self.project_logger.warning("Could not find file with path %s, making "
"new one", infile)
document_file = DocumentFile()
except MultipleResultsFound:
self.project_logger.error("Found multiple files with path %s, "
"skipping.", infile)
return DocumentFile()
for extracted_unit in extracted_units:
document = Document()
document.properties = extracted_unit.properties
document.sentences = extracted_unit.sentences
document.title = _get_title(document.properties)
document.children = extracted_unit.children
document.number = doc_num
assign_sentences(document)
document_file.documents.append(document)
document.save(False)
db.session.commit()
return document_file
def __init__(self):
loader = Loader()
document = Document(loader, "post", ["title", "content"])
fields = {"index": ["title", "content"], "show": ["_id", "title"]}
searcher = Searcher(document, fields)
searcher.fit()
while True:
query = input("Enter your query: ")
searcher.search(query)
def document_update(id):
edit_one_field = request.form.get('edit_one_field', None)
if not edit_one_field:
form = DocumentEditForm(formdata=request.form, id=id)
else:
form = DocumentEditOneKeyForm(formdata=request.form, id=id)
if not form.validate():
return Fail(message=form.first_error)
document = Document.get_by_id(id=id)
document.update(form.data, edit_one_field)
return Success(message="操作成功！")
def documents(request):
s = None
if request.DATA['signature']:
s = Signature(signature=request.DATA['signature'],
user_id=request.DATA['user'])
s.save()
if 'template' not in request.DATA:
d = Document(company_id=request.DATA['company'],
user_id=request.DATA['user'],
name=request.DATA['document']['name'],
signature=s,
content=request.DATA['document']['content'],
upload_id=request.DATA['document']['upload']
)
else:
d = Document(company_id=request.DATA['company'],
user_id=request.DATA['user'],
name=request.DATA['document']['name'],
content=_generate_content(request.DATA['template'],
request.DATA['document']['fields']),
upload_id=request.DATA['document']['upload'],
signature=s
)
d.save()
serializer = DocumentSerializer(d)
return Response(serializer.data)
def test_get_document_file(client: CustomFlaskClient, auth_header: any):
document = (DocumentModel.select().where(
DocumentModel.deleted_at.is_null()).order_by(
fn.Random()).limit(1).get())
document_id = document.id
db_wrapper.database.close()
headers = auth_header()
headers['Content-Type'] = 'application/octet-stream'
response = client.get(f'/api/documents/{document_id}', headers=headers)
assert 200 == response.status_code
assert isinstance(response.get_data(), bytes)
def test_delete_document(client: CustomFlaskClient, auth_header: any):
document_id = (DocumentModel.select(DocumentModel.id).where(
DocumentModel.deleted_at.is_null()).order_by(
fn.Random()).limit(1).get().id)
db_wrapper.database.close()
response = client.delete('/api/documents/%s' % document_id,
json={},
headers=auth_header())
json_response = response.get_json()
json_data = json_response.get('data')
assert 200 == response.status_code
assert document_id == json_data.get('id')
assert json_data.get('deleted_at') is not None
assert json_data.get('deleted_at') >= json_data.get('updated_at')
def test_team_dataroom_roles(db: Session, data: Data, oso: Oso):
# make sure that a user that does not have direct
# room roles can still manage room because of a team
# role
user_roles_in_room_1: List = oso_roles.get_user_roles(
db, data.member_team_1, Dataroom, data.room_1.id)
# user does not have direct access to the room
count_of_roles = len(user_roles_in_room_1)
assert count_of_roles == 0
# but still gets it via his team role (which is a members role)
assert oso.is_allowed(data.member_team_1, "READ", data.room_1) is True
assert oso.is_allowed(data.member_team_1, "LIST_DOCUMENTS",
data.room_1) is True
assert oso.is_allowed(data.member_team_1, "DELETE", data.room_1) is False
assert oso.is_allowed(data.member_team_1, "UPDATE", data.room_1) is False
assert oso.is_allowed(data.member_team_1, "INVITE_GUESTS",
data.room_1) is False
# does not have access to other rooms
assert oso.is_allowed(data.member_team_1, "READ", data.room_2) is False
assert oso.is_allowed(data.member_team_1, "LIST_DOCUMENTS",
data.room_2) is False
# is allowed to create his own documents in a room
new_document_team_member_1 = Document(
name="New Doc Team Member 1",
description="Test",
file_name="new_doc_team_member_1",
extension="txt",
md5_sum=UUID("87a6909ab71ec463f013325dbf9f3543"),
mime_type="text/plain",
size=50,
creator=data.member_team_1,
dataroom=data.room_1,
)
assert (oso.is_allowed(data.member_team_1, "CREATE",
new_document_team_member_1) is True)
def test_search_document(client: CustomFlaskClient, auth_header: any):
document_name = (DocumentModel.select(DocumentModel.name).where(
DocumentModel.deleted_at.is_null()).order_by(
fn.Random()).limit(1).get().name)
db_wrapper.database.close()
json_body = {
'search': [
{
'field_name': 'name',
'field_operator': 'eq',
'field_value': document_name,
},
],
'order': [
{
'field_name': 'name',
'sorting': 'desc',
},
],
}
response = client.post('/api/documents/search',
json=json_body,
headers=auth_header())
json_response = response.get_json()
document_data = json_response.get('data')
records_total = json_response.get('records_total')
records_filtered = json_response.get('records_filtered')
assert 200 == response.status_code
assert isinstance(document_data, list)
assert records_total > 0
assert 0 < records_filtered <= records_total
assert document_data[0].get('name').find(document_name) != -1
def test_dataroom_roles(db: Session, data: Data, oso: Oso):
# Guest can access the documents for the room in which he is guest
assert oso.is_allowed(data.guest_read_user_room_1, "READ",
data.room_1) is True
assert (oso.is_allowed(data.guest_read_user_room_1, "LIST_DOCUMENTS",
data.room_1) is True)
assert (oso.is_allowed(data.guest_read_user_room_1, "READ",
data.document_room_1) is True)
# Guest cannot see other datarooms
assert (oso.is_allowed(data.guest_read_user_room_1, "LIST_ROOMS",
data.first_org) is False)
assert oso.is_allowed(data.guest_read_user_room_1, "READ",
data.room_2) is False
assert (oso.is_allowed(data.guest_read_user_room_1, "READ",
data.document_room_2) is False)
new_document_guest_1 = Document(
name="Test Document",
description="Test",
file_name="hallo",
extension="txt",
md5_sum=UUID("87a6909ab71ec463f013325dbf9f3541"),
mime_type="text/plain",
size=50,
creator=data.guest_read_user_room_1,
dataroom=data.room_1,
)
new_document_guest_2 = Document(
name="New Doc Guest 2",
description="Test",
file_name="new_doc_guest_2",
extension="txt",
md5_sum=UUID("87a6909ab71ec463f013325dbf9f3541"),
mime_type="text/plain",
size=50,
creator=data.guest_write_user_room_1,
dataroom=data.room_1,
)
# Only guest with write access can create a new document
assert (oso.is_allowed(data.guest_write_user_room_1, "CREATE",
new_document_guest_2) is True)
assert (oso.is_allowed(data.guest_read_user_room_1, "CREATE",
new_document_guest_1) is False)
# add the second new document to db so that we can test edits
db.add(new_document_guest_2)
db.commit()
db.refresh(new_document_guest_2)
assert (oso.is_allowed(data.guest_write_user_room_1, "UPDATE",
new_document_guest_2) is True)
assert (oso.is_allowed(data.guest_write_user_room_1, "DELETE",
new_document_guest_2) is True)
assert (oso.is_allowed(data.guest_write_user_room_1, "UPDATE",
data.document_room_1) is False)
assert (oso.is_allowed(data.guest_write_user_room_1, "DELETE",
data.document_room_1) is False)
assert (oso.is_allowed(data.admin_user_room_1, "UPDATE",
data.document_room_1) is True)
assert (oso.is_allowed(data.admin_user_room_1, "DELETE",
data.document_room_1) is True)
# Only OWNERS can delete a dataroom
assert oso.is_allowed(data.member_user_org_1, "DELETE",
data.room_1) is True
assert oso.is_allowed(data.guest_read_user_room_1, "DELETE",
data.room_1) is False
assert oso.is_allowed(data.guest_write_user_room_1, "DELETE",
data.room_1) is False
# Admin are allowed to invite_guests
assert oso.is_allowed(data.admin_user_room_1, "INVITE_GUESTS",
data.room_1) is True
assert oso.is_allowed(data.admin_user_room_1, "INVITE_GUESTS",
data.room_2) is False
new_document_member_1 = Document(
name="New Doc Member 1",
description="Test",
file_name="new_doc_member_1",
extension="txt",
md5_sum=UUID("87a6909ab71ec463f013325dbf9f3543"),
mime_type="text/plain",
size=50,
creator=data.member_user_room_1,
dataroom=data.room_1,
)
# Members can create documents and edit and delete their own
assert (oso.is_allowed(data.member_user_room_1, "CREATE",
new_document_member_1) is True)
db.add(new_document_member_1)
db.commit()
db.refresh(new_document_member_1)
assert (oso.is_allowed(data.member_user_room_1, "UPDATE",
new_document_member_1) is True)
assert (oso.is_allowed(data.member_user_room_1, "DELETE",
new_document_member_1) is True)
assert (oso.is_allowed(data.member_user_room_1, "UPDATE",
new_document_guest_2) is False)
assert (oso.is_allowed(data.member_user_room_1, "DELETE",
new_document_guest_2) is False)
def document_lists():
total, result = Document.get_limit_all()
return AjaxResponse(data=result, count=total)
def document_delete(ids):
ids = ids.split('-')
documentes = Document.get_all_in_ids(ids=ids)
for document in documentes:
document.destroy()
return Success(message="成功删除")
