def get_response(self) -> JsonResponse:
rmodel: DeleteInstructionDocumentPageEventRequestModel = self.request_model
user_id = get_jwt_identity()['id']
repo = InstructionDocumentPageRepository()
page: InstructionDocumentPage = repo.get(rmodel.page_id)
managed_doc = InstructionDocumentManager(document_id=page.document_id)
managed_doc.delete_page(user_id, page_num=page.page_num)
return ok_response()
def get_response(self) -> JsonResponse:
rmodel: RegisterUserEventRequestModel = self.request_model
user = User(email=rmodel.email,
plaintext_password=rmodel.password,
username=rmodel.username)
UserRepository().save(user)
self.__add_user_to_default_groups(user)
return ok_response(data=UserManager(user=user).user_model)
def get_response(self) -> JsonResponse:
rdoc: UpdateInstructionDocumentEventRequestModel = self.request_model
managed_doc = InstructionDocumentManager(document_id=rdoc.document_id)
managed_doc.update(get_jwt_identity()['id'],
name=rdoc.name,
description=rdoc.description)
return ok_response(
InstructionDocumentEntityModel.from_orm(managed_doc.document))
def get_response(self) -> JsonResponse:
user: User = UserRepository().get(get_jwt_identity()['id'])
doc = InstructionDocument(created_by=user,
name=self.request.json['name'].strip(),
description=self.request.json.get(
'description', None))
InstructionDocumentRepository().save(doc)
return ok_response(InstructionDocumentEntityModel.from_orm(doc))
def get_response(self) -> JsonResponse:
user = self.__auth_user()
if not user: raise AuthError('Invalid credentials')
rdata_model = TokenAuthEventResponseDataModel.construct(
token=create_access_token(identity=UserManager(
user=user).user_model.dict()))
return ok_response(data=rdata_model)
def get_response(self) -> JsonResponse:
rmodel: AddInstructionDocumentPageEventRequestModel = self.request_model
user_id = get_jwt_identity()['id']
page = InstructionDocumentPage(document_id=rmodel.document_id,
md=rmodel.md)
managed_doc = InstructionDocumentManager(
document_id=rmodel.document_id)
page = managed_doc.add_page(page, user_id)
return ok_response(InstructionDocumentPageEntityModel.from_orm(page))
def get_response(self) -> JsonResponse:
docs_paginated = InstructionDocumentRepository() \
.all_paginated(page=self.request.json['page'], limit=self.request.json['limit'], order='id desc')
rdata = ListInstructionDocumentEventResponseDataModel(
total=docs_paginated.total,
page=docs_paginated.page,
next_num=docs_paginated.next_num,
prev_num=docs_paginated.prev_num,
results=docs_paginated.items)
return ok_response(rdata)
def add_file():
""" upload file """
file = request.files.get('file', None)
if not file: raise ValidationError('file is missing', 'file')
filename, ext = tuple(file.filename.rsplit('.', 1))
if ext.lower().strip() not in ALLOWED_EXTENSIONS:
raise ValidationError('invalid file extension', 'file')
filename += f'{str(uuid.uuid4())[:7].replace("-", "")}.{ext}'
filename = secure_filename(filename)
file.save(os.path.join(UPLOAD_FOLDER, filename))
return ok_response({'uploaded_filename': filename})
def get_response(self) -> JsonResponse:
user_id = get_jwt_identity()['id']
rmodel: UpdateInstructionDocumentPageEventRequestModel = self.request_model
repo = InstructionDocumentPageRepository()
page: InstructionDocumentPage = repo.get(rmodel.page_id)
page.md = rmodel.md
repo.save(page)
managed_doc = InstructionDocumentManager(document_id=page.document_id)
managed_doc.update(user_id)
return ok_response(InstructionDocumentPageEntityModel.from_orm(page))
def get_response(self) -> JsonResponse:
rmodel: SearchInstructionDocumentEventRequestModel = self.request_model
search = rmodel.search.lower().strip()
docs_paginated = InstructionDocumentRepository() \
.filter_paginated(f=or_(InstructionDocument.name.ilike(f'%{search}%'),
InstructionDocument.description.ilike(f'%{search}%')),
page=rmodel.page,
limit=rmodel.limit,
order='id desc')
rdata = ListInstructionDocumentEventResponseDataModel(
total=docs_paginated.total,
page=docs_paginated.page,
next_num=docs_paginated.next_num,
prev_num=docs_paginated.prev_num,
results=docs_paginated.items)
return ok_response(rdata)
def get_response(self) -> JsonResponse:
rmodel: GetInstructionDocumentEventRequestModel = self.request_model
by, val = (
'slug',
rmodel.document_slug) if rmodel.document_slug is not None else (
'id', rmodel.document_id)
doc = InstructionDocumentRepository().get_by(**{by: val})
doc_entity = InstructionDocumentEntityModel.from_orm(doc)
pages = InstructionDocumentPageRepository().filter(
InstructionDocumentPage.document_id == doc.id)
pages_entities = [
InstructionDocumentPageEntityModel.from_orm(p) for p in pages
]
data_dict = doc_entity.dict()
data_dict['pages'] = pages_entities
rdata = GetInstructionDocumentEventResponsedataModel(**data_dict)
return ok_response(rdata)
def get_response(self) -> JsonResponse:
InstructionDocumentRepository().delete(
self.request.json['document_id'])
return ok_response()
def get_response(self) -> JsonResponse:
rmodel: GetUserDataEventRequestModel = self.request_model
user_id = rmodel.user_id if rmodel.user_id else get_jwt_identity(
)['id']
return ok_response(data=UserManager(user_id=user_id).user_model)
def get_response(self) -> JsonResponse:
rmodel: DeleteUserEventRequestModel = self.request_model
managed_user = UserManager(user_id=rmodel.user_id)
managed_user.delete()
return ok_response(data=managed_user.user_model)
