def get_cell_history(token: str,
cell_id: int,
res: Response,
with_closed: bool = False):
token_user, error, code = get_user_by_token(token)
if error:
res.status_code = code
return error
l = [
x.to_dict() for x in select(
t for t in Lease if t.is_returned in (with_closed, False) and
t.cell_id.id == cell_id).order_by(lambda y: desc(y.start_time))[:]
]
history = []
for lease in l:
curr = lease.copy()
try:
u = User[curr["user_id"]]
curr["user_name"] = u.first_name
curr["user_surname"] = u.last_name
curr["user_email"] = u.email
except RowNotFound:
curr["user_name"], curr["user_surname"], curr["user_email"] = (
None,
None,
None,
)
history.append(curr)
return history
def update_user_info(user: UpdateInfoUser, token: str, res: Response):
token_user, error, code = get_user_by_token(token)
if error:
res.status_code = code
return error
if token_user.id != user.id and not token_user.is_admin:
res.status_code = status.HTTP_400_BAD_REQUEST
return {"err": "Non admin users can only update their info!"}
try:
user_for_update = User[user.id]
except RowNotFound:
user_for_update = None
if user_for_update is None:
res.status_code = status.HTTP_400_BAD_REQUEST
return {"err": f"No user with id {user.id} found!"}
user_for_update.first_name = user.name
user_for_update.last_name = user.surname
commit()
res = user_for_update.to_dict()
res.pop("password", None)
return res
def new_lease(token: str, cell_type: int, res: Response):
token_user, error, code = get_user_by_token(token)
if error:
res.status_code = code
return error
available_cell_types = get_available_cell_types()
if cell_type not in available_cell_types:
res.status_code = status.HTTP_400_BAD_REQUEST
return {"err": "No cell with such type is available!"}
current_time = datetime.utcnow()
current_cell = get_free_cell(cell_type)
if current_cell is None:
res.status_code = status.HTTP_400_BAD_REQUEST
return {"err": "All equipment with such type is taken!"}
l = Lease(
start_time=current_time,
cell_id=current_cell.id,
user_id=token_user.id,
is_returned=False,
)
commit()
current_token = create_new_token(token_user.id, l.id)
l.token_id = current_token.id
current_cell.is_taken = True
commit()
return {"token": current_token.value, "cell": current_cell.id}
def get_leases_by_user(token: str, res: Response, with_closed: bool = False):
token_user, error, code = get_user_by_token(token)
if error:
res.status_code = code
return error
l = [
x.to_dict()
for x in select(
u
for u in Lease
if u.user_id.id == token_user.id and u.is_returned in (with_closed, False)
)[:]
]
res = []
for lease in l:
t = Token.get(lease_id=lease["id"])
if t is None:
res.status_code = status.HTTP_400_BAD_REQUEST
return {"err": f"Lease without token with id {lease['id']}"}
try:
c = Cell[lease["cell_id"]]
except RowNotFound:
c = None
if c is None:
res.status_code = status.HTTP_400_BAD_REQUEST
return {"err": f"Lease without cell with id {lease['id']}"}
current = lease
current["token"] = t.value
current["cell_type"] = c.cell_type_id
res.append(current)
return res
def get_passes(token: str, res: Response, user_id: int = None):
token_user, error, code = get_user_by_token(token)
if error:
res.status_code = code
return error
if not token_user.is_admin and user_id != token_user.id:
res.status_code = status.HTTP_400_BAD_REQUEST
return {"err": "Only admins can view passes of other users!"}
if user_id is not None:
check_id = user_id
else:
check_id = token_user.id
types = [
PassType(name=t.name, id=t.id) for t in select(c for c in Pass_Type)[:]
]
passes = [
x.to_dict()
for x in select(t for t in Pass if t.user_id.id == check_id)
]
res = []
for p in passes:
curr = p.copy()
curr["type_name"] = types[curr["pass_type"] - 1].name
res.append(curr)
return res
def get_cell_types(token: str, res: Response):
token_user, error, code = get_user_by_token(token)
if error:
res.status_code = code
return error
types = [
CellType(name=t.name, id=t.id) for t in select(c for c in Cell_Type)[:]
]
return types
def list_users(token: str, res: Response):
token_user, error, code = get_user_by_token(token)
if error:
res.status_code = code
return error
if not token_user.is_admin:
res.status_code = status.HTTP_405_METHOD_NOT_ALLOWED
return {"err": f"User with email {token_user.email} is not admin!"}
u = [x.to_dict() for x in select(u for u in User)[:]]
return {"Users": u}
def user_admin(id: int, token: str, is_admin: bool, res: Response):
token_user, error, code = get_user_by_token(token)
if error:
res.status_code = code
return error
try:
u = User[id]
except RowNotFound:
res.status_code = status.HTTP_404_NOT_FOUND
return {"err": f"No user with id {id} found"}
u.is_admin = is_admin
commit()
return {"id": u.id, "is_admin": u.is_admin}
def get_user(id: int, token: str, res: Response):
token_user, error, code = get_user_by_token(token)
if error:
res.status_code = code
return error
try:
u = User[id]
except RowNotFound:
res.status_code = status.HTTP_404_NOT_FOUND
return {"err": f"No user with id {id} found"}
message = u.to_dict()
message.pop("password", None)
return message
def update_password(token: str, old_password: str, new_password: str, res: Response):
token_user, error, code = get_user_by_token(token)
if error:
res.status_code = code
return error
is_valid_pass = verify_password(old_password, token_user.password)
if not is_valid_pass:
res.status_code = status.HTTP_401_UNAUTHORIZED
return {"err": f"Incorrect old password"}
hashed_new_pass = get_password_hash(new_password)
token_user.password = hashed_new_pass
return {"Success!"}
def add_pass(token: str, pass_value: str, pass_type: int, res: Response):
token_user, error, code = get_user_by_token(token)
if error:
res.status_code = code
return error
types = [t.id for t in select(c for c in Pass_Type)[:]]
if pass_type not in types:
res.status_code = status.HTTP_400_BAD_REQUEST
return {"err": "No such pass type exists!"}
p = Pass(user_id=token_user.id, pass_value=pass_value, pass_type=pass_type)
commit()
return p.id
def cancel_lease(token: str, lease_id: int, res: Response):
token_user, error, code = get_user_by_token(token)
if error:
res.status_code = code
return error
try:
l = Lease[lease_id]
t = Token[l.token_id]
except RowNotFound:
res.status_code = status.HTTP_400_BAD_REQUEST
return {"err": "No such lease exists!"}
t.delete()
l.delete()
return {f"Lease with {lease_id} id deleted!"}
def get_all_leases(token: str, res: Response, with_closed: bool = False):
token_user, error, code = get_user_by_token(token)
if error:
res.status_code = code
return error
if not token_user.is_admin:
res.status_code = status.HTTP_400_BAD_REQUEST
return {"err": "Token user is not admin!"}
l = [
x.to_dict()
for x in select(t for t in Lease if t.is_returned in (with_closed, False))[:]
]
return l
def remove_pass(token: str, pass_id: int, res: Response):
token_user, error, code = get_user_by_token(token)
if error:
res.status_code = code
return error
try:
p = Pass[pass_id]
except RowNotFound:
res.status_code = status.HTTP_400_BAD_REQUEST
return {"err": "No such pass exists!"}
if p.user_id.id != token_user.id:
res.status_code = status.HTTP_400_BAD_REQUEST
return {"err": "You can only remove your own passes!"}
p.delete()
commit()
return {"Success"}
def get_all_passes(token: str, res: Response):
token_user, error, code = get_user_by_token(token)
if error:
res.status_code = code
return error
if not token_user.is_admin:
res.status_code = status.HTTP_400_BAD_REQUEST
return {"err": "Token user is not admin!"}
passes = [x.to_dict() for x in select(t for t in Pass)]
types = [
PassType(name=t.name, id=t.id) for t in select(c for c in Pass_Type)[:]
]
res = []
for p in passes:
curr = p.copy()
curr["type_name"] = types[curr["pass_type"] - 1].name
res.append(curr)
return res
def current_types(token: str, res: Response):
token_user, error, code = get_user_by_token(token)
if error:
res.status_code = code
return error
cells = [
x.to_dict() for x in select(c for c in Cell if c.is_taken == False)[:]
]
free_types = set()
res = []
for cell in cells:
if cell["cell_type_id"] not in free_types:
free_types.add(cell["cell_type_id"])
t = dict()
t["id"] = cell["cell_type_id"]
try:
t["name"] = Cell_Type[cell["cell_type_id"]].name
except RowNotFound:
t["name"] = None
res.append(t)
return res
def all_statistics(token: str, res: Response):
token_user, error, code = get_user_by_token(token)
if error:
res.status_code = code
return error
if not token_user.is_admin:
res.status_code = status.HTTP_400_BAD_REQUEST
return {"err": "Token user is not admin!"}
user_growth_by_date = [
UserGrowth(date=x[0].strftime("%Y-%m-%d"), count=x[1])
for x in select((u.create_date, count(u)) for u in User)[:]
]
cell_types = [
CellType(name=t.name, id=t.id) for t in (select(
c for c in Cell_Type).order_by(lambda x: desc(x.id)))[:]
]
lease_growth_by_date = [
LeaseGrowth(date=l[0], count=l[1]) for l in db.select(
"""select to_char(date(date_trunc('day', l.start_time)), 'YYYY-MM-DD') as date, count(l.id) as count
from lease l
group by date_trunc('day', l.start_time)
order by date_trunc('day', l.start_time)""")
]
equipment_free_ratio = [
EquipmentFreeRatio(id=x[0],
free=x[2],
total=x[1],
name=cell_types[-x[0]].name)
for x in select(
(t.cell_type_id, count(t.id), count(t.is_taken == False))
for t in Cell)[:]
]
leases_by_type = [
LeasesByType(type_id=x[0], name=x[1], count=x[2]) for x in db.select(
"""select c.cell_type_id as id, min(ct.name) as name, count(l.id)
from lease l
join cell c on c.id = l.cell_id
join cell_type ct on c.cell_type_id = ct.id
group by c.cell_type_id
order by c.cell_type_id""")
]
leases_by_type_and_date = [
LeasesByTypeAndDate(type_id=x[0], name=x[1], count=x[2], date=x[3])
for x in db.select(
"""select c.cell_type_id as id, min(ct.name) as name, count(l.id) as count, to_char(date(date_trunc('day', l.start_time)), 'YYYY-MM-DD') as day
from lease l
join cell c on c.id = l.cell_id
join cell_type ct on c.cell_type_id = ct.id
group by c.cell_type_id, date_trunc('day', l.start_time)
order by date_trunc('day', l.start_time), c.cell_type_id;""")
]
return {
"user_growth_by_date": user_growth_by_date,
"equipment_free_ratio": equipment_free_ratio,
"leases_by_type": leases_by_type,
"leases_by_type_and_date": leases_by_type_and_date,
"lease_growth_by_date": lease_growth_by_date,
}
