class Inspection:
def __init__(self) -> None:
super().__init__()
pass
@staticmethod
# @auth_required(UserRole.DRIVER)
@docs(tags=["mobile-inspection"],
summary="Get last Logs by date range",
description=("Get list of Logs by given date range as query"),
parameters=Param().query('startDate',
"date").query('endDate', "date").build())
async def hand_review(request):
# https://docs.aiohttp.org/en/2.0.7/web.html#file-uploads
# https://stackoverflow.com/questions/34121814/aiohttp-serve-single-static-file
org_id = request.user['org_id']
start_date = request.rel_url.query.get("startDate")
end_date = request.rel_url.query.get("endDate")
try:
assert start_date and end_date
start_date = parse(start_date)
end_date = parse(end_date)
except:
return VError(
detail="Invalid query, startDate and endDate expected")
result, driver = {}, {}
try:
# Get Events and Log
from executors.log.log_cli import LogClient
log_cli = LogClient()
result: dict = await log_cli.get_by_date(org_id=org_id,
start_date=start_date,
end_date=end_date)
if not len(result) or not result:
return web.json_response(data={"data": {}}, dumps=custom_dumps)
# todo get: driver, org, terminal, log, eld, timezone, vehicle
# Get Driver
# driver_id = result.values()[0]
# from executors.driver.driver_client import DriverClient
# driver_cli = DriverClient()
# driver = await driver_cli.get_one()
# assert driver_cli
data = {}
location = await to_pdf('inspection.html', 'inspection.pdf', data)
except Exception as ex:
return HTTPServiceError(ex.__cause__)
return web.FileResponse('./index.html')
class Eld:
def __init__(self):
self.client = EldClient()
@docs(
tags=["eld"],
summary="Create",
description=("Create Eld item. 'unit' field request should be: "
"```{'1': 1} # {str(unit_id): int(unit_id)}```.\n"
"**NOTE: If something uncomfortable with request structure, ask for edit**"),
responses=Response().created('{"eld_id": 0}')._401._422._500.build(),
)
@request_schema(EldSchema)
async def create_eld(self, request):
org_id = 1
data = await request.json()
try:
validated_data = eld_schema.load(data)
validated_data['organization_id'] = org_id
except ValidationError as err:
return VError(detail=err.messages)
try:
eld_id = await self.client.add(data=validated_data)
except Exception as ex:
raise ex
return web.json_response(
status=200,
data={"eld_id": eld_id.get('id')}
)
@docs(
tags=["eld"],
summary="Update ELD item",
description=("Update ELD item. 'unit' field request should be: "
"```{'1': 1} # {str(unit_id): int(unit_id)}```.\n"
"**NOTE: If something uncomfortable with request structure, ask for edit**"),
responses=Response()._401._422._500.build(),
)
@request_schema(EldEditSchema)
@response_schema(EldSchema(), 200)
async def update_eld(self, request):
data = await request.json()
eld_id = request.match_info['eld_id']
try:
validated_data = eld_edit_schema.load(data)
except ValidationError as err:
return VError(detail=err.messages)
validated_data['id'] = int(eld_id)
try:
eld_update = await self.client.modify(data=validated_data)
except Exception as ex:
raise ex
return web.json_response(
data=eld_update
)
@docs(
tags=["eld"],
summary="ELDs list",
description=("All ELDs List"),
responses=Response().list(EldListSchema)._401._422._500.build(),
parameters=Param().paginate().build()
)
async def get_eld_list(self, request):
org_id = 1
limit = request.rel_url.query.get("limit")
offset = request.rel_url.query.get("offset")
try:
if limit and offset:
eld_list = await self.client.paginate(limit=int(limit), offset=int(offset), organization_id=org_id)
else:
eld_list = await db_get_by_org_id(org_id)
except Exception as ex:
raise ex
return web.json_response(
data={"data": eld_list}
)
@docs(
tags=["eld"],
summary="Get one",
description=("Get one ELD item"),
responses=Response()._401._404._422._500.build(),
)
@response_schema(EldSchema(), 200)
async def get_eld_info(self, request):
eld_id = request.match_info['eld_id']
try:
response = await self.client.get_by_id(id=eld_id)
if not response:
return web.json_response(
status=404,
)
except Exception as ex:
raise ex
return web.json_response(
status=200,
data=response
)
@docs(
tags=["eld"],
summary="Delete",
description=("Delete ELD item"),
responses=Response()._200._401._404._422._500.build(),
parameters=Param().url_path("eld_id").build()
)
async def delete_eld(self, request):
eld_id = request.match_info['eld_id']
try:
delete = await self.client.remove(id=int(eld_id))
if not delete:
return web.json_response(
status=404
)
except Exception as ex:
raise ex
return web.json_response(
status=200
)
@docs(
tags=["eld"],
summary="Search",
description=("Search for ELD item"),
responses=Response().list(EldListSchema)._401._422._500.build(),
parameters=Param().header("search").paginate().build()
)
async def search(self, request):
org_id = 1
limit = request.rel_url.query.get("limit")
offset = request.rel_url.query.get("offset")
text = request.headers.get("search")
obj_list = []
try:
if limit and offset:
obj_list = await db_search(
limit=int(limit),
offset=int(offset),
organization_id=org_id,
text=text)
except Exception as ex:
raise ex
return web.json_response(
data={"data": obj_list},
status=200
)
class Log:
def __init__(self) -> None:
super().__init__()
pass
@staticmethod
@auth_required(UserRole.DRIVER)
@docs(tags=["mobile-log"],
summary="Get last Logs by date range",
description=("Get list of Logs by given date range as query"),
parameters=Param().query('startDate',
"date").query('endDate', "date").build())
async def get_by_date(request):
org_id = request.user['org_id']
start_date = request.rel_url.query.get("startDate")
end_date = request.rel_url.query.get("endDate")
try:
assert start_date and end_date
start_date = parse(start_date)
end_date = parse(end_date)
except:
return VError(
detail="Invalid query, startDate and endDate expected")
result = {}
try:
from executors.log.log_cli import LogClient
log_cli = LogClient()
vehicles = await log_cli.get_by_date(org_id=org_id,
start_date=start_date,
end_date=end_date)
except Exception as ex:
raise ex
return web.json_response(data={"data": vehicles}, dumps=custom_dumps)
@staticmethod
@auth_required(UserRole.DRIVER)
@docs(
tags=["mobile-log"],
summary="Get one",
description=("Get one Groups item"),
responses=Response()._401._404._422._500.build(),
)
@response_schema(LogSchema(), 200)
async def get_info(self, request):
log_id = request.match_info['log_id']
try:
from executors.log.log_cli import LogClient
cli = LogClient()
response = await cli.get_by_id(id=log_id)
if not response:
return web.json_response(status=404, )
except Exception as ex:
raise ex
return web.json_response(
status=200,
data=response,
dumps=custom_dumps,
)
class Event:
def __init__(self) -> None:
super().__init__()
pass
@docs(
tags=["event"],
summary="Create not for web app",
description=
("New event item. 'unit' field request should be: "
"```{'1': 1} # {str(unit_id): int(unit_id)}```.\n"
"**NOTE: If something uncomfortable with request structure, ask for edit**"
),
parameters=Param().url_path("log_id").build(),
responses=Response()._401._422._500.build(),
)
@request_schema(EventSchema)
@response_schema(EventSchema(), 200)
async def insert(self, request):
org_id = 1 # request.user['org_id']
try:
data = event_schema.load(await request.json())
data['organization_id'] = org_id
except ValidationError as err:
return VError(detail=err.messages)
try:
from executors.event.event_cli import EventClient
event_cli = EventClient()
event = await event_cli.add(data=data)
except UniqueViolationError as e:
return VError(detail={e.constraint_name: e.args[0]})
except Exception as ex:
raise ex
return web.json_response(status=200, data=event)
@docs(
tags=["event"],
summary="Update Driving Event item",
description=
("Update Driving Event item. 'unit' field request should be: "
"```{'1': 1} # {str(unit_id): int(unit_id)}```.\n"
"**NOTE: If something uncomfortable with request structure, ask for edit**"
),
parameters=Param().url_path("event_id").build(),
responses=Response()._401._422._500.build(),
)
@request_schema(EventSchema)
@response_schema(EventSchema(), 200)
async def update(self, request):
event_id = request.match_info['event_id']
try:
serialized_data = event_schema.load(await request.json())
serialized_data['id'] = int(event_id)
except ValidationError as err:
return VError(detail=err.messages)
try:
from executors.event.event_cli import EventClient
event_cli = EventClient()
event_update = await event_cli.modify(data=serialized_data)
except Exception as ex:
raise ex
return web.json_response(data=event_update, dumps=custom_dumps)
class DrivingEvent:
def __init__(self):
self.de_client = DrivingEventClient()
self.event_client = EventClient()
@docs(
tags=["driving-event"],
summary="Create not for web app",
description=
("New driving_event item. 'unit' field request should be: "
"```{'1': 1} # {str(unit_id): int(unit_id)}```.\n"
"**NOTE: If something uncomfortable with request structure, ask for edit**"
),
responses=Response().created(
'{"driving_event_id": 0}')._401._422._500.build(),
)
@request_schema(DrivingEventSchema)
async def create(self, request):
org_id = 1
data = await request.json()
try:
serialized_data = driving_event_schema.load(data)
serialized_data['organization_id'] = org_id
except ValidationError as err:
return VError(detail=err.messages)
try:
driving_event_id = await self.event_client.add(data=serialized_data
)
except UniqueViolationError as e:
return VError(detail={e.constraint_name: e.args[0]})
except Exception as ex:
raise ex
return web.json_response(
status=200, data={"driving_event_id": driving_event_id.get('id')})
@docs(
tags=["driving-event"],
summary="Update Driving Event item",
description=
("Update Driving Event item. 'unit' field request should be: "
"```{'1': 1} # {str(unit_id): int(unit_id)}```.\n"
"**NOTE: If something uncomfortable with request structure, ask for edit**"
),
responses=Response()._401._422._500.build(),
)
@request_schema(DrivingEditEventSchema)
async def update(self, request):
data = await request.json()
driving_event_id = request.match_info['driving_event_id']
data['id'] = int(driving_event_id)
try:
serialized_data = driving_event_edit_schema.load(data)
except ValidationError as err:
return VError(detail=err.messages)
try:
driving_event_update = await self.event_client.modify(
data=serialized_data)
except Exception as ex:
raise ex
return web.json_response(data=driving_event_update, dumps=custom_dumps)
@docs(tags=["driving-event"],
summary="Delete",
description=("Delete Driving Event item"),
responses=Response()._200._401._404._422._500.build(),
parameters=Param().url_path("driving_event_id").build())
async def delete(self, request):
driving_event_id = request.match_info['driving_event_id']
try:
delete = await self.event_client.remove(id=int(driving_event_id))
if not delete:
return web.json_response(status=404)
except Exception as ex:
raise ex
return web.json_response(status=200)
@docs(
tags=["driving-event"],
summary="Get one",
description=("Get one Driving Event item"),
responses=Response()._401._404._422._500.build(),
)
@response_schema(DrivingEventSchema(), 200)
async def get_info(self, request):
driving_event_id = request.match_info['driving_event_id']
try:
driving_event = await self.event_client.get_by_id(
id=driving_event_id)
if not driving_event:
return web.json_response(status=404, data={})
except Exception as ex:
raise ex
if driving_event is None:
driving_event = {}
return web.json_response(data=driving_event, dumps=custom_dumps)
@docs(tags=["driving-event"],
summary="Driving Event list",
description=("All Driving Event List"),
responses=Response().list(
DrivingEventListSchema)._401._422._500.build(),
parameters=Param().paginate().query('startDate', "date").query(
'endDate').query('driver_id').query('vehicle_id').build())
async def get_list(self, request):
org_id = 1
limit = request.rel_url.query.get("limit")
offset = request.rel_url.query.get("offset")
start_date = request.rel_url.query.get("startDate")
end_date = request.rel_url.query.get("endDate")
driver_id = request.rel_url.query.get("driver_id")
vehicle_id = request.rel_url.query.get("vehicle_id")
try:
if isinstance(start_date, datetime.date):
start_date = str(start_date)
if isinstance(end_date, datetime.date):
end_date = str(end_date)
if isinstance(start_date, datetime.datetime):
start_date = str(start_date.date())
if isinstance(end_date, datetime.datetime):
end_date = str(end_date.date())
except:
return VError(
detail="date, datetime or str-date expected: '2020-01-30'")
vehicles = {}
try:
if limit and offset:
vehicles = await db_paginate(
limit=int(limit),
offset=int(offset),
organization_id=org_id,
start_date=start_date,
end_date=end_date,
driver_id=driver_id,
vehicle_id=vehicle_id,
)
else:
pass
except Exception as ex:
raise ex
return web.json_response(data={"data": vehicles}, dumps=custom_dumps)
@docs(tags=["driving-event"],
summary="Search",
description=("Search for Driving Event item"),
responses=Response().list(
DrivingEventListSchema)._401._422._500.build(),
parameters=Param().header("search").paginate().build())
@response_schema(DrivingEventSchema(), 200)
async def search(self, request):
org_id = 1
text = request.headers.get("search")
limit = request.rel_url.query.get("limit")
offset = request.rel_url.query.get("offset")
vehicles = {}
try:
if limit and offset:
vehicles = await db_search(limit=int(limit),
offset=int(offset),
organization_id=org_id,
text=text)
except Exception as ex:
raise ex
if vehicles:
for item in vehicles:
item['year'] = str(item.get('year'))
return web.json_response(data={"data": vehicles},
dumps=custom_dumps,
status=200)
class Drivers:
@staticmethod
# @auth_required
@docs(
tags=["driver"],
summary="Create",
description=
("Create Driver item. 'unit' field request should be: "
"```{'1': 1} # {str(unit_id): int(unit_id)}```.\n"
"**NOTE: If something uncomfortable with request structure, ask for edit**"
),
responses=Response().created(
'{"driver_id": 0}')._401._422._500.build(),
)
@request_schema(DriverSchema)
async def create_driver(request):
org_id = 1
# await user_view.check_permission(request, 'admin')
driver_client = DriverClient()
user_client = UserClient()
data = await request.json()
try:
serialized_data = driver_schema.load(data)
serialized_data['organization_id'] = org_id
except ValidationError as err:
raise HTTPServiceError()
await user_view.is_unique(request)
try:
result = await driver_client.add(data=serialized_data)
except UniqueViolationError as e:
return VError(detail={e.constraint_name: e.args[0]})
except Exception as ex:
raise ex
return web.json_response(status=200,
data={
"driver_id": result.get('id'),
})
@staticmethod
# @auth_required
@docs(
tags=["driver"],
summary="Update Driver item",
description=
("Update Driver item. 'unit' field request should be: "
"```{'1': 1} # {str(unit_id): int(unit_id)}```.\n"
"**NOTE: If something uncomfortable with request structure, ask for edit**"
),
responses=Response()._401._422._500.build(),
parameters=Param().url_path("driver_id").build())
@request_schema(DriverEditSchema)
@response_schema(DriverSchema(), 200)
async def update_driver(request):
driver_client = DriverClient()
driver_id = request.match_info['driver_id']
data = await request.json()
try:
serialized_data = driver_edit_schema.load(data)
serialized_data['id'] = int(driver_id)
except ValidationError as err:
return ValidError(detail=err.messages)
try:
update = await driver_client.modify(data=serialized_data)
except Exception as ex:
raise HTTPServiceError()
return web.json_response(
status=200,
data={"driver_id": update},
dumps=custom_dumps,
)
@staticmethod
# @auth_required
# @docs(
# tags=["driver"],
# summary="Delete",
# description=("Delete Driver item"),
# responses=Response()._200._401._404._422._500.build(),
# parameters=Param().url_path("driver_id").build()
# )
async def delete_driver(request):
driver_client = DriverClient()
driver_id = request.match_info['driver_id']
try:
delete = await driver_client.remove(id=int(driver_id))
if not delete:
return web.json_response(status=404)
except Exception as ex:
raise HTTPServiceError()
return web.json_response(status=200)
@staticmethod
# @auth_required
@docs(
tags=["driver"],
summary="Get one",
description=("Get one Driver item"),
responses=Response()._401._404._422._500.build(),
# parameters=Param().header("Authorization").build()
)
@response_schema(DriverSchema(), 200)
async def get_driver_info(request):
driver_client = DriverClient()
driver_id = request.match_info['driver_id']
try:
driver = await driver_client.get_by_id(id=driver_id)
if not driver:
return web.json_response(status=404, data={})
except Exception as ex:
raise HTTPServiceError()
if driver is None:
driver = []
return web.json_response(status=200, data=driver, dumps=custom_dumps)
@staticmethod
# @auth_required
@docs(tags=["driver"],
summary="Drivers list",
description=("All Drivers List\n"
"Status: 1(activated), 0(deactivated)"),
responses=Response().list(DriverListSchema)._401._422._500.build(),
parameters=Param().paginate().query('status', 'int').build())
async def get_driver_list(request):
driver_client = DriverClient()
org_id = 1
limit = request.rel_url.query.get("limit")
offset = request.rel_url.query.get("offset")
status = request.rel_url.query.get("status", 1)
try:
if limit and offset:
drivers = await db_paginate(limit=int(limit),
offset=int(offset),
status=int(status),
organization_id=org_id)
else:
drivers = await db_get_by_status(org_id, int(status))
except Exception as ex:
raise HTTPServiceError()
return web.json_response(status=200,
data={"data": drivers},
dumps=custom_dumps)
@docs(tags=["driver"],
summary="Search",
description=("Search for Vehicle item"),
responses=Response().list(DriverListSchema)._401._422._500.build(),
parameters=Param().header("search").paginate().build())
@response_schema(DriverSchema(), 200)
async def search(self, request):
org_id = 1
text = request.headers.get("search")
limit = request.rel_url.query.get("limit")
offset = request.rel_url.query.get("offset")
drivers = {}
try:
if limit and offset:
drivers = await db_search(limit=int(limit),
offset=int(offset),
organization_id=org_id,
text=text)
except Exception as ex:
raise ex
return web.json_response(data={"data": drivers},
dumps=custom_dumps,
status=200)
@docs(tags=["driver"],
summary="Deactivate/Activate Driver",
description=("(De)Activate Driver item"),
responses=Response()._200._400._401._422._500.build(),
parameters=Param().url_path("driver_id").query_req(
"status", type='int').build())
async def change_status(self, request):
driver_id = request.match_info['driver_id']
status = request.rel_url.query.get("status")
if not status:
return web.json_response(status=400)
try:
response = await self.client.modify_status(id=int(driver_id),
status=int(status))
if not response:
return web.json_response(status=500)
except Exception as ex:
raise ex
return web.json_response(status=200)
class Unit:
def __init__(self):
self.client = UnitClient()
@docs(
tags=["unit"],
summary="Create",
description=
("Create unit item. 'groups' field request should be: "
"```{'1': 1} # {str(group_id): int(group_id)}```.\n"
"or as a list ```['1', 1]``` "
"**NOTE: If something uncomfortable with request structure, ask for edit**"
),
responses=Response().created('{"unit_id": 0}')._401._422._500.build(),
)
@request_schema(UnitSchema)
async def create(self, request):
org_id = 1
data = await request.json()
try:
if isinstance(data['groups'], list):
data['groups'] = dict(
zip(map(lambda x: str(x), data['groups']), data['groups']))
serialized_data = unit_schema.load(data)
serialized_data['organization_id'] = org_id
except ValidationError as err:
return VError(detail=err.messages)
try:
unit_id = await self.client.add(data=serialized_data)
except Exception as ex:
raise ex
return web.json_response(status=200,
data={"unit_id": unit_id.get('id')})
@docs(
tags=["unit"],
summary="Update Unit item",
description=
("Update Unit item. 'unit' field request should be: "
"```{'1': 1} # {str(unit_id): int(unit_id)}```.\n"
"**NOTE: If something uncomfortable with request structure, ask for edit**"
),
responses=Response()._401._422._500.build(),
)
@request_schema(UnitEditSchema)
async def update(self, request):
data = await request.json()
unit_id = request.match_info['unit_id']
data['id'] = int(unit_id)
try:
if isinstance(data['groups'], list):
data['groups'] = dict(
zip(map(lambda x: str(x), data['groups']), data['groups']))
serialized_data = unit_edit_schema.load(data)
except ValidationError as err:
return VError(detail=err.messages)
try:
unit_update = await self.client.modify(data=serialized_data)
except Exception as ex:
raise ex
return web.json_response(data={"unit_id": unit_update},
dumps=custom_dumps)
@docs(tags=["unit"],
summary="Delete",
description=("Delete Unit item"),
responses=Response()._200._401._404._422._500.build(),
parameters=Param().url_path("unit_id").build())
async def delete(self, request):
unit_id = request.match_info['unit_id']
try:
delete = await self.client.remove(id=int(unit_id))
if not delete:
return web.json_response(status=404)
except Exception as ex:
raise HTTPServiceError()
return web.json_response(status=200)
@docs(
tags=["unit"],
summary="Get one",
description=("Get one Unit item"),
responses=Response()._401._404._422._500.build(),
)
@response_schema(UnitSchema(), 200)
async def get_info(self, request):
unit_id = request.match_info['unit_id']
try:
unit = await self.client.get_by_id(id=unit_id)
if not unit:
return web.json_response(status=404, data={})
except Exception as ex:
raise HTTPServiceError()
if unit is None:
unit = {}
return web.json_response(data=unit, dumps=custom_dumps)
@docs(tags=["unit"],
summary="Unit list",
description=("All Unit List"),
responses=Response().list(UnitListSchema)._401._422._500.build(),
parameters=Param().paginate().build())
async def get_list(self, request):
org_id = 1
limit = request.rel_url.query.get("limit")
offset = request.rel_url.query.get("offset")
units_list = {}
try:
if limit and offset:
units_list = await db_paginate(limit=int(limit),
offset=int(offset),
organization_id=org_id)
units = await self.client.get_all()
except Exception as ex:
raise ex
return web.json_response(
data={"data": units_list},
dumps=custom_dumps,
)
@docs(tags=["unit"],
summary="Search",
description=("Search for Unit item"),
responses=Response().list(UnitListSchema)._401._422._500.build(),
parameters=Param().header("search").paginate().build())
async def search(self, request):
org_id = 1
text = request.headers.get("search")
limit = request.rel_url.query.get("limit")
offset = request.rel_url.query.get("offset")
units_list = {}
try:
if limit and offset:
units_list = await db_search(limit=int(limit),
offset=int(offset),
organization_id=org_id,
text=text)
except Exception as ex:
raise ex
return web.json_response(
data={"data": units_list},
status=200,
dumps=custom_dumps,
)
class Vehicle:
def __init__(self):
self.client = VehicleClient()
@docs(
tags=["vehicle"],
summary="Create",
description=("New Vehicle item. 'unit' field request should be: "
"```{'1': 1} # {str(vehicle_id): int(vehicle_id)}```.\n"
"**NOTE: If something uncomfortable with request structure, ask for edit**"),
responses=Response().created('{"vehicle_id": 0}')._401._422._500.build(),
)
@request_schema(VehicleSchema)
async def create_vehicle(self, request):
org_id = 1
data = await request.json()
try:
validated_data = vehicle_schema.load(data)
validated_data['organization_id'] = org_id
except ValidationError as err:
return VError(detail=err.messages)
try:
vehicle_id = await self.client.add(data=validated_data)
except UniqueViolationError as e:
return VError(detail={e.constraint_name: e.args[0]})
except Exception as ex:
raise ex
return web.json_response(
status=200,
data={"vehicle_id": vehicle_id.get('id')}
)
@docs(
tags=["vehicle"],
summary="Update Vehicle item",
description=("Update Vehicle item. 'unit' field request should be: "
"```{'1': 1} # {str(vehicle_id): int(vehicle_id)}```.\n"
"**NOTE: If something uncomfortable with request structure, ask for edit**"),
responses=Response()._401._422._500.build(),
)
@request_schema(VehicleEditSchema)
@response_schema(VehicleSchema(), 200)
async def update_vehicle(self, request):
vehicle_id = request.match_info['vehicle_id']
data = await request.json()
data['id'] = int(vehicle_id)
try:
validated_data = vehicle_edit_schema.load(data)
except ValidationError as err:
return VError(detail=err.messages)
try:
vehicle_update = await self.client.modify(data=validated_data)
except Exception as ex:
raise ex
return web.json_response(
data={"vehicle_id": vehicle_update}
)
@docs(
tags=["vehicle"],
summary="Delete",
description=("Delete Vehicle item"),
responses=Response()._200._401._404._422._500.build(),
parameters=Param().url_path("vehicle_id").build()
)
async def delete_vehicle(self, request):
vehicle_id = request.match_info['vehicle_id']
try:
delete = await self.client.remove(id=int(vehicle_id))
if not delete:
return web.json_response(
status=404
)
except Exception as ex:
raise HTTPServiceError()
return web.json_response(
status=200
)
@docs(
tags=["vehicle"],
summary="Get one",
description=("Get one Vehicle item"),
responses=Response()._401._404._422._500.build(),
)
@response_schema(VehicleSchema(), 200)
async def get_vehicle_info(self, request):
vehicle_id = request.match_info['vehicle_id']
try:
result = await self.client.get_by_id(id=vehicle_id)
if not result:
return web.json_response(
status=404,
data={}
)
except Exception as ex:
raise HTTPServiceError()
result['year'] = str(result.get('year'))
return web.json_response(
data=result,
dumps=custom_dumps,
)
@docs(
tags=["vehicle"],
summary="Vehicles list",
description=("All Vehicles List\n"
"Status: 1(activated), 0(deactivated)"),
responses=Response().list(VehicleListSchema)._401._422._500.build(),
parameters=Param().paginate().query('status', 'int').build()
)
async def get_vehicle_list(self, request):
org_id = 1
limit = request.rel_url.query.get("limit")
offset = request.rel_url.query.get("offset")
status = request.rel_url.query.get("status", 1)
try:
if limit and offset:
vehicles = await db_paginate(
limit=int(limit), offset=int(offset), status=int(status),
organization_id=org_id)
else:
vehicles = await db_get_by_status(org_id, int(status))
except Exception as ex:
raise ex
if vehicles:
for item in vehicles:
item['year'] = str(item.get('year'))
return web.json_response(
data={"data": vehicles},
dumps=custom_dumps,
)
@docs(
tags=["vehicle"],
summary="Search",
description=("Search for Vehicle item"),
responses=Response().list(VehicleListSchema)._401._422._500.build(),
parameters=Param().header("search").paginate().build()
)
@response_schema(VehicleSchema(), 200)
async def search(self, request):
org_id = 1
text = request.headers.get("search")
limit = request.rel_url.query.get("limit")
offset = request.rel_url.query.get("offset")
vehicles = {}
try:
if limit and offset:
vehicles = await db_search(
limit=int(limit),
offset=int(offset),
organization_id=org_id,
text=text)
except Exception as ex:
raise ex
if vehicles:
for item in vehicles:
item['year'] = str(item.get('year'))
return web.json_response(
data={"data": vehicles},
dumps=custom_dumps,
status=200
)
@docs(
tags=["vehicle"],
summary="Deactivate/Activate Vehicle",
description=("(De)Activate Vehicle item"),
responses=Response()._200._400._401._422._500.build(),
parameters=Param().url_path("vehicle_id").query_req("status", type='int').build()
)
async def change_status(self, request):
vehicle_id = request.match_info['vehicle_id']
status = request.rel_url.query.get("status")
if not status:
return web.json_response(
status=400
)
try:
response = await self.client.modify_status(
id=int(vehicle_id), status=int(status))
if not response:
return web.json_response(
status=500
)
except Exception as ex:
raise ex
return web.json_response(
status=200
)
class User:
async def login(self, request):
# todo request: keep me logedin
data = await request.json()
async with request.app['db'].acquire() as conn:
result = await conn.execute(users.select().where(
and_(users.c.username == data['username'],
users.c.password == data['password'])))
user = await result.first()
if user:
auth_token = encode_auth_token(user.id)
if auth_token:
response_object = {
'status': 'success',
'message': 'Successfully logged in.',
'auth_token': auth_token.decode()
}
return web.json_response(data=response_object)
else:
return web.json_response(data={"error": "Wrong credentials"})
async def register(self, request):
# todo request:
#
data = await request.json()
pass
async def logoff(self, request):
pass
async def check_permission(self, request, role):
try:
user = request.user
except Exception as ex:
raise HTTPForbidden(detail="Wrong permissions")
user_role = user.get('role', None)
if role == 'admin' or (role is not None and role == user_role):
return
raise HTTPForbidden(detail="Wrong permissions")
async def is_authorized(self, request):
auth_header = request.headers.get('Authorization', None)
if not auth_header:
return False, 'Token required'
if auth_header:
try:
auth_token = auth_header.split(" ")[1]
except IndexError:
request.user = "******"
return False, "invalid token"
else:
auth_token = ''
if auth_token:
try:
resp = decode_auth_token(auth_token)
except Exception as err:
request.user = "******"
return False, "invalid_token"
if not isinstance(resp, str):
async with request.app['db'].acquire() as conn:
result = await conn.execute(
users.select().where(users.c.id == resp))
user = await result.first()
if user:
request.user = {
"id": user.id,
"username": user.username,
"role": user.role,
"date_created": str(user.date_created),
"org_id": user.organization_id,
}
return True, user.username
else:
return False, "Unauthorized"
async def is_unique(self, request, **kwargs):
data = await request.json()
async with request.app['db'].acquire() as conn:
result = await conn.execute(users.select().where(
and_(users.c.username == data['username'])))
user = await result.first()
if user:
VError("Username exists. Please, choose another one")
@docs(tags=["user"],
summary="Activate User",
description=("Activate User"),
responses=Response()._200._400._401._422._500.build(),
parameters=Param().url_path("user_id").build())
async def activate(self, request):
user_id = request.match_info['user_id']
if not user_id:
VError("user_id missing")
try:
user_cli = UserClient()
response = await user_cli.set_status(data={
"id": int(user_id),
"status": 1,
})
if not response:
return web.json_response(status=500)
except Exception as ex:
raise ex
return web.json_response(status=200)
@docs(
tags=["user"],
summary="Deactivate User",
description="Deactivate User",
responses=Response()._200._400._401._422._500.build(),
# parameters=Param().url_path("user_id").build()
)
async def deactivate(self, request):
user_id = request.match_info['user_id']
if not user_id:
VError("user_id missing")
try:
user_cli = UserClient()
response = await user_cli.set_status(data={
"id": int(user_id),
"status": 0,
})
if not response:
return web.json_response(status=500)
except Exception as ex:
raise ex
return web.json_response(status=200)
class LogEditRequest:
def __init__(self):
pass
# self.client = VehicleClient()
@staticmethod
@auth_required(UserRole.DRIVER)
@docs(
tags=["mobile_log_edit_request"],
summary="Log Edit Request list",
description=("All Log Edit Request List"),
responses=Response().list(
EditedEventListSchema)._401._422._500.build(),
)
@request_schema(LogEditReqestSchema)
async def get_list(request):
try:
data = log_edit_request_schema.load(await request.json())
except ValidationError as err:
return VError(detail=err.messages)
org_id = request.user['org_id']
try:
vehicles = await db_get_first_by_status(
EventEditedCodeEnum.WAITING, org_id, int(data['driver_id']))
except Exception as ex:
return HTTPServiceError()
return web.json_response(
data={"data": vehicles},
dumps=custom_dumps,
)
@staticmethod
@auth_required(UserRole.DRIVER)
@docs(tags=["mobile_log_edit_request"],
summary="Log Edit Request Details",
description=("Log Edit Request Details with current and edited log"),
parameters=Param().url_path("log_id").build())
@response_schema(EditedAndCurrentEvent(), 200)
async def details(request):
log_id = request.match_info['log_id']
try:
edited_events = await edited_event_get_by_log_id(log_id=int(log_id)
)
events = await event_get_by_log_id(log_id=int(log_id))
assert edited_events and events
except Exception as ex:
return HTTPServiceError()
return web.json_response(
data={
"current_log": events,
"edited_log": edited_events
},
dumps=custom_dumps,
)
@staticmethod
@auth_required(UserRole.DRIVER)
@docs(
tags=["mobile_log_edit_request"],
summary="Accept Log Edit Request",
description=("Accept Log Edit Request Details by given log_id"),
parameters=Param().url_path("log_id").build(),
responses=Response().list(
EditedEventListSchema)._401._422._500.build(),
)
async def accept(request):
log_id = request.match_info['log_id']
try:
from executors.edited_event.edited_event_cli import EditEventClient
edite_event_cli = EditEventClient()
result = await edite_event_cli.request_make_action(
log_id=int(log_id), accept=True)
assert result
except Exception as ex:
return HTTPServiceError()
return web.json_response(
data={True},
dumps=custom_dumps,
)
@staticmethod
@auth_required(UserRole.DRIVER)
@docs(
tags=["mobile_log_edit_request"],
summary="Reject Log Edit Request",
description=("Reject Log Edit Request Details by given log_id"),
parameters=Param().url_path("log_id").build(),
responses=Response().list(
EditedEventListSchema)._401._422._500.build(),
)
async def reject(request):
log_id = request.match_info['log_id']
try:
from executors.edited_event.edited_event_cli import EditEventClient
edite_event_cli = EditEventClient()
result = await edite_event_cli.request_make_action(
log_id=int(log_id), accept=False)
assert result
except Exception as ex:
return HTTPServiceError()
return web.json_response(
data={True},
dumps=custom_dumps,
)
async def multipart_test(self, request: web.Request) -> web.Response:
f1 = "/home/sa/Desktop/startup/us_project/logi-back-py/font-colors.pdf"