async def test_send_request_changes_request_status(contractor_representative_out):
await RequestsDAL.add_worker_to_request(contractor_representative_out, 1, 1)
res = await RequestsDAL.send_request(contractor_representative_out, 1)
assert res.status == RequestStatus.WAITING_FOR_VERIFICATION
with create_session() as session:
request = session.query(Request).filter(Request.id == 1).one()
assert request.status == RequestStatus.WAITING_FOR_VERIFICATION
async def test_reset_worker_in_request_status(contractor_representative_out, ):
await RequestsDAL.accept_worker(1, 1)
res = await RequestsDAL.reset_worker_in_request_status(1, 1)
assert res.status == WorkerInRequestStatus.WAITING_FOR_VERIFICATION
with create_session() as session:
worker = session.query(WorkerInRequest).filter(WorkerInRequest.id == 1).one()
assert worker.status == WorkerInRequestStatus.WAITING_FOR_VERIFICATION
async def add_worker(contractor_representative: OutUser, last_name: str,
first_name: str, patronymic: str, birthday: date,
profession: str, **kwargs) -> WorkerWithProfessionOut:
with create_session() as session:
try:
profession = (session.query(Profession).filter(
Profession.data == profession).one())
except NoResultFound:
raise DALError(
HTTPStatus.BAD_REQUEST.value,
Message.PROFESSION_DOES_NOT_EXITS.value,
)
contractor_representative_from_db = await RepresentativesDAL._get_contractor_representative(
contractor_representative, session)
worker = Worker(
patronymic=patronymic,
last_name=last_name,
first_name=first_name,
birth_date=birthday,
profession=profession,
contractor_id=contractor_representative_from_db.contractor_id,
)
for key, value in kwargs.items():
if hasattr(Worker, key) and value:
await DocumentsDAL.add_worker_document(
session, worker, key, SimpleDocumentIn(file=value))
session.flush()
worker_out = WorkerOut.from_orm(worker)
return WorkerWithProfessionOut(**worker_out.dict(),
profession=worker.profession.data)
def get_worker_from_requests(representative_id: int, request_id: int,
substring: str, page: int, size: int):
with create_session() as session:
request = RequestsDAL._get_request(request_id, session)
try:
representative = (
session.query(ContractorRepresentative).filter(
ContractorRepresentative.id ==
representative_id).one())
except NoResultFound:
raise DALError(HTTPStatus.NOT_FOUND.value)
if request not in representative.contractor.requests:
raise DALError(HTTPStatus.FORBIDDEN.value)
res = []
for worker_in_request in request.workers_in_request:
worker = worker_in_request.worker
if (substring and substring not in
f'{worker.last_name} {worker.first_name} {worker.patronymic}'
):
continue
res.append(
RequestsDAL.serialize_worker_with_request_info(
worker, worker_in_request))
return get_pagination(res, page, size)
async def test_refresh_tokens_saves_new_tokens_pair_to_db(
username, password, tokens):
new_tokens = await refresh_tokens(tokens.refresh_token.decode())
with create_session() as session:
user = session.query(User).filter(User.username == username).first()
assert user.refresh_token == new_tokens.refresh_token.decode()
assert user.access_token == new_tokens.access_token.decode()
def get_representative_request_result(request_id: int,
representative_id: int,
substring: str, page: int,
size: int):
with create_session() as session:
try:
representative = (
session.query(ContractorRepresentative).filter(
ContractorRepresentative.id ==
representative_id).one())
except NoResultFound:
raise DALError(HTTPStatus.NOT_FOUND.value)
request = RequestsDAL._get_request(request_id, session)
if request not in representative.contractor.requests:
raise DALError(HTTPStatus.FORBIDDEN.value)
if request.status != RequestStatus.WAITING_FOR_READINESS:
raise DALError(HTTPStatus.NOT_FOUND.value)
workers = map(
lambda worker_in_request: worker_in_request.worker,
request.workers_in_request,
)
res = [
RequestsDAL.serialize_worker(worker) for worker in workers
if substring and substring in f''
f'{worker.last_name} {worker.first_name} {worker.patronymic}'
or not substring
]
return get_pagination(res, page, size)
def get_representative_requests(
representative_id: int,
substring: str,
page: int,
size: int,
solved: bool = False,
) -> Awaitable[ListWithPagination[RequestForTemplateOut]]:
with create_session() as session:
try:
representative: ContractorRepresentative = session.query(
ContractorRepresentative).filter(
ContractorRepresentative.id ==
representative_id).one()
except NoResultFound:
raise DALError(HTTPStatus.NOT_FOUND.value)
res = []
for request in representative.contractor.requests:
if substring and substring not in request.object_of_work.data:
continue
if solved and request.status != RequestStatus.CLOSED:
continue
if (not solved and request.status !=
RequestStatus.WAITING_FOR_VERIFICATION):
continue
res.append(RequestsDAL._serialize_request(request))
return get_pagination(res, page, size)
async def test_close_request(contractor_representative_out):
await RequestsDAL.accept_worker(1, 1)
res = await RequestsDAL.close(1)
assert res.status == RequestStatus.CLOSED
with create_session() as session:
request = session.query(Request).filter(Request.id == 1).one()
assert request.status == RequestStatus.CLOSED
def _add_db_obj_to_register_to_db(
self, obj: T,
out_model: Type[TAddingUserOut]) -> Awaitable[TAddingUserOut]:
with create_session() as session:
session.add(obj)
session.flush()
return out_model.from_orm(obj) # type: ignore
async def test_add_request(request_in, contractor_representative_out):
res = await RequestsDAL.add(contractor_representative_out, request_in)
with create_session() as session:
request = session.query(Request).filter(Request.id == 1).one()
assert request.contractor_id == res.contractor_id == 1
assert request.object_of_work_id == res.object_of_work_id == 1
assert request.contract_id == res.contract_id == 3
assert request.status == RequestStatus.WAITING_FOR_READINESS
def get_user(req: Request) -> Awaitable[OutUser]:
tokens = get_tokens(req)
with create_session() as session:
user = (session.query(User).filter(
User.access_token == tokens.access_token).first())
if user:
return OutUser.from_orm(user) # type: ignore
raise DALError(HTTPStatus.UNAUTHORIZED.value)
async def test_deny_worker(deny_worker_in):
res = await RequestsDAL.deny_worker(1, 1, deny_worker_in)
assert res.status == WorkerInRequestStatus.CANCELLED
with create_session() as session:
worker_in_request = (
session.query(WorkerInRequest).filter(WorkerInRequest.id == 1).one()
)
assert worker_in_request.status == WorkerInRequestStatus.CANCELLED
def remove_user_to_register(uuid: str) -> None:
with create_session() as session:
user = (session.query(UserToRegister).filter(
UserToRegister.uuid == uuid).first())
if not user:
raise DALError(HTTPStatus.BAD_REQUEST.value,
Message.USER_DOES_NOT_EXISTS.value)
session.delete(user)
def accept_worker(request_id: int,
worker_id: int) -> Awaitable[WorkerInRequestOut]:
with create_session() as session:
request = RequestsDAL._get_request(request_id, session)
worker = RequestsDAL._get_worker(session, worker_id)
RequestsDAL._validate_data(request, worker)
worker.status = WorkerInRequestStatus.ACCEPTED
return WorkerInRequestOut.from_orm(worker)
async def test_add_with_real_profession_will_raise_error(
out_user, worker_fields, profession):
await RepresentativesDAL.add_worker(**worker_fields,
profession=profession,
contractor_representative=out_user)
with create_session() as session:
worker = session.query(Worker).filter(Worker.id == 1).first()
assert worker.profession.data == profession
async def test_accept_worker(contractor_representative_out, ):
res = await RequestsDAL.accept_worker(1, 1)
assert res.status == WorkerInRequestStatus.ACCEPTED
with create_session() as session:
worker_in_request: WorkerInRequest = session.query(WorkerInRequest).filter(
WorkerInRequest.id == 1
).one()
assert worker_in_request.status == WorkerInRequestStatus.ACCEPTED
def _save_tokens_to_db(
user: OutUser, access_token: bytes, refresh_token: bytes
) -> None:
with create_session() as session:
user_from_db = session.query(UserDB).filter(UserDB.id == user.id).one()
user_from_db.refresh_token = refresh_token.decode()
user_from_db.access_token = access_token.decode()
session.add(user_from_db)
async def test_add_same_request_second_time_will_delete_first_and_delete_workers_in_request_connected_with_request(
request_in, contractor_representative_out
):
await RequestsDAL.add_worker_to_request(contractor_representative_out, 1, 1)
await RequestsDAL.add(contractor_representative_out, request_in)
with create_session() as session:
assert not session.query(Request).filter(Request.id == 1).first()
request = session.query(Request).filter(Request.id == 2).one()
assert len(request.workers_in_request) == 0
async def test_delete_worker_from_request(contractor_representative_out):
await RequestsDAL.add_worker_to_request(contractor_representative_out, 1, 1)
await RequestsDAL.delete_worker_from_request(
contractor_representative_out, request_id=1, worker_id=1
)
with create_session() as session:
assert (
not session.query(WorkerInRequest).filter(WorkerInRequest.id == 1).first()
)
def get(self, uuid: str) -> Awaitable[TOutModel]:
with create_session() as session:
try:
document = session.query(Document).filter(
Document.uuid == uuid).one()
out_model = get_document_out_model(document.type)
return out_model.from_orm(document) # type: ignore
except NoResultFound:
raise DALError(HTTPStatus.NOT_FOUND.value)
def register(self, params: SimpleRegistrationParams) -> Awaitable[OutUser]:
with create_session() as session:
user = self._add_user(
session,
username=params.username,
password=params.password,
db_obj=get_db_obj(params.type),
)
return OutUser.from_orm(user) # type: ignore
def delete_catalog(catalog_id: int) -> Awaitable[None]: # type: ignore
with create_session() as session:
try:
catalog = session.query(Catalog).filter(
Catalog.id == catalog_id).one()
session.delete(catalog)
except NoResultFound:
raise DALError(HTTPStatus.NOT_FOUND.value,
Message.CATALOG_DOES_NOT_EXISTS.value)
async def test_worker_document_adding(worker_document, upload_file, uuid4,
path):
WorkerDocument.save_file.return_value = DocumentParams(path, uuid4)
with create_session() as session:
worker = Worker(last_name='1',
first_name='2',
patronymic='3',
birth_date=datetime.utcnow())
await worker_document.add(session, worker, 'identification',
SimpleDocumentIn(file=upload_file))
with create_session() as session:
identification = (session.query(Identification).filter(
Identification.id == 1).one())
worker = session.query(Worker).filter(Worker.id == 1).one()
assert worker.identification == identification
assert identification.path_to_document == str(path)
assert identification.uuid == uuid4
assert identification.worker == worker
def get_worker_violations(worker_id: int) -> List[WorkerPenaltyOut]:
with create_session() as session:
worker = SecuritiesDAL._get_worker(session, worker_id)
return [
WorkerPenaltyOut(created_at=penalty.created_at,
data=penalty.violation.data,
value=penalty.violation.value,
object=penalty.object_of_work.data)
for penalty in worker.penalties
]
def close(request_id: int) -> Awaitable[RequestOut]:
with create_session() as session:
request = RequestsDAL._get_request(request_id, session)
if request.status != RequestStatus.WAITING_FOR_VERIFICATION:
raise DALError(HTTPStatus.BAD_REQUEST.value)
if WorkerInRequestStatus.WAITING_FOR_VERIFICATION in map(
lambda worker: worker.status, request.workers_in_request):
raise DALError(HTTPStatus.BAD_REQUEST.value)
request.status = RequestStatus.CLOSED
return RequestOut.from_orm(request) # type: ignore
async def test_add_same_request_second_time_will_delete_first(
request_in, contractor_representative_out
):
res = await RequestsDAL.add(contractor_representative_out, request_in)
assert res.id == 2
assert res.contract_id == 3
assert res.contractor_id == 1
with create_session() as session:
assert not session.query(Request).filter(Request.id == 1).first()
assert session.query(Request).filter(Request.id == 2).one()
async def test_add_worker_to_request(contractor_representative_out):
res = await RequestsDAL.add_worker_to_request(contractor_representative_out, 1, 1)
with create_session() as session:
worker_in_request: WorkerInRequest = session.query(WorkerInRequest).filter(
WorkerInRequest.id == 1
).one()
worker = session.query(Worker).filter(Worker.id == 1).one()
assert len(worker.worker_requests) == 1
assert worker_in_request.request_id == 1
assert worker_in_request.status == WorkerInRequestStatus.WAITING_FOR_READINESS
def add_penalty(worker_id: int, params: PenaltyIn):
with create_session() as session:
worker = SecuritiesDAL._get_worker(session, worker_id)
penalty = Penalty(violation_id=params.violation_id,
worker_id=worker_id,
object_of_work_id=params.object_of_work_id,
created_at=date.today())
session.add(penalty)
session.flush()
worker.penalty_points = worker.penalty_points + penalty.violation.value
def _authenticate_user(username: str, password: str) -> Awaitable[OutUser]:
message = Message.INCORRECT_USERNAME_OR_PASSWORD.value
with create_session() as session:
user: Optional[UserDB] = session.query(UserDB).filter(
UserDB.username == username
).first()
if user is None:
raise DALError(HTTPStatus.NOT_FOUND.value, message)
if _is_password_correct(password, user.password_hash):
return OutUser.from_orm(user) # type: ignore
raise DALError(HTTPStatus.NOT_FOUND.value, message)
async def test_reset_worker_in_request_status_if_worker_was_cancelled(
contractor_representative_out, deny_worker_in
):
await RequestsDAL.deny_worker(1, 1, deny_worker_in)
res = await RequestsDAL.reset_worker_in_request_status(1, 1)
assert res.status == WorkerInRequestStatus.WAITING_FOR_VERIFICATION
with create_session() as session:
worker = session.query(WorkerInRequest).filter(WorkerInRequest.id == 1).one()
assert worker.status == WorkerInRequestStatus.WAITING_FOR_VERIFICATION
assert not worker.reason_for_rejection
assert not worker.comment