Collaborative

backend/db/crud.py

@@ -2,6 +2,7 @@
 Module to interact with the database
 """
 from datetime import date, datetime, time, timedelta
+from fastapi import HTTPException
 from sqlalchemy.orm import Session
 from sqlalchemy.sql import func
 from sqlalchemy import Time, Date, cast
@@ -44,7 +45,8 @@ def add_slot(slots_list, start_time, end_time, function):
     average_waiting_time = function(start_time, end_time)
     if average_waiting_time:
         name = 60 * start_time.hour + start_time.minute
-        slots_list.append(schemas.RecordRead(name=name, time=average_waiting_time))
+        slots_list.append(schemas.RecordRead(
+            name=name, time=average_waiting_time))
 
 
 def get_avg_graph_points(place: str, weekday: int, min_time: time,
@@ -149,18 +151,8 @@ def get_comments(place: str, page: int, db: Session):
             models.Comments.published_at.desc(),
             models.Comments.id.desc()).all()
     else:
-        comments = db.query(
-            models.Comments,
-            models.Users.username).join(
-            models.Users).filter(
-            models.Comments.place == place).order_by(
-                models.Comments.published_at.desc(),
-                models.Comments.id.desc()).slice(
-                    (page -
-                     1) *
-                    20,
-                    page *
-            20).all()
+        comments = db.query(models.Comments, models.Users.username).join(models.Users).filter(models.Comments.place == place).order_by(
+            models.Comments.published_at.desc(), models.Comments.id.desc()).slice((page - 1) * 20, page * 20).all()
     comments_list = list(schemas.Comment(
         **comment.__dict__, username=username) for comment, username in comments)
     comments_list.reverse()
@@ -290,9 +282,18 @@ def init_user(db: Session):
 
 def get_user(cookie: str, db: Session):
     """ Get user infos """
-    user = db.query(models.Users).filter(models.Users.cookie == cookie).one()
+    try:
+        user = db.query(models.Users).filter(
+            models.Users.cookie == cookie).one()
+    except BaseException:
+        raise HTTPException(status_code=401, detail="Invalid cookie")
+
     if pytz.timezone("Europe/Paris").localize(user.expiration_date) < datetime.now(tz=pytz.timezone("Europe/Paris")):
-        return
+        user.cookie = None
+        db.add(user)
+        db.commit()
+        raise HTTPException(status_code=401, detail="Expired cookie")
+
     return user
 
 
@@ -329,6 +330,111 @@ def update_user(user: schemas.User, user_info: dict, db: Session):
 def end_session(cookie: str, db: Session):
     user = db.query(models.Users).filter(models.Users.cookie == cookie).one()
     user.expiration_date = datetime.now(tz=pytz.timezone("Europe/Paris"))
+    user.cookie = None
     db.add(user)
     db.commit()
     return
+
+
+def delete_user(cookie: str, db: Session):
+    db.query(models.Users).filter(models.Users.cookie == cookie).delete()
+    db.commit()
+    return
+
+
+# Define CRUD operations for data collection
+
+def get_records(place: str, db: Session):
+    records = db.query(models.Records).filter(
+        models.Records.place == place).order_by(models.Records.date.desc()).all()
+    return records
+
+
+def create_record(record: schemas.RecordBase, db: Session):
+    db_record = models.Records(**record.dict())
+    db.add(db_record)
+    db.commit()
+    db.refresh(db_record)
+    return db_record
+
+
+def delete_record(id: int, db: Session):
+    if id == 0:
+        db.query(models.Records).delete()
+    else:
+        db.query(models.Records).filter(models.Records.id == id).delete()
+    db.commit()
+    return
+
+
+def get_collaborative_records(place: str, db: Session):
+    records = db.query(models.CollaborativeRecords).filter(
+        models.CollaborativeRecords.place == place).order_by(models.CollaborativeRecords.date.desc()).all()
+    return [schemas.CollaborativeRecords(**record.__dict__) for record in records]
+
+
+def create_collaborative_record(user: schemas.User, place: str, db: Session):
+    current_date = datetime.now(tz=pytz.timezone("Europe/Paris"))
+    date, weekday, current_time = current_date.date(
+    ), current_date.weekday(), current_date.time()
+
+    try:
+        time_slot = db.query(
+            models.OpeningHours).filter(
+            models.OpeningHours.place == place,
+            models.OpeningHours.day == weekday,
+            models.OpeningHours.open_time <= current_time,
+            models.OpeningHours.close_time >= current_time).one()
+    except BaseException:
+        raise HTTPException(status_code=404, detail="No restaurant opened")
+
+    last_record = db.query(models.CollaborativeRecords).filter(
+        models.CollaborativeRecords.user_id == user.id).order_by(models.CollaborativeRecords.date.desc()).first()
+    if not last_record or last_record.date <= datetime.combine(date, time_slot.open_time):
+        db_record = models.CollaborativeRecords(
+            user_id=user.id, place=place, date=current_date)
+        db.add(db_record)
+        db.commit()
+        db.refresh(db_record)
+        return db_record
+
+    raise HTTPException(status_code=406, detail="Client already registered")
+
+
+def update_collaborative_record(user: schemas.User, db: Session):
+    current_date = datetime.now(tz=pytz.timezone("Europe/Paris"))
+    date, weekday, current_time = current_date.date(
+    ), current_date.weekday(), current_date.time()
+    last_record = db.query(models.CollaborativeRecords).filter(
+        models.CollaborativeRecords.user_id == user.id).order_by(models.CollaborativeRecords.date.desc()).first()
+
+    try:
+        time_slot = db.query(
+            models.OpeningHours).filter(
+            models.OpeningHours.place == last_record.place,
+            models.OpeningHours.day == weekday,
+            models.OpeningHours.open_time <= current_time,
+            models.OpeningHours.close_time >= current_time).one()
+    except BaseException:
+        raise HTTPException(status_code=404, detail="No restaurant opened")
+
+    if last_record.date >= datetime.combine(date, time_slot.open_time) and not last_record.waiting_time:
+        last_record.waiting_time = current_date - \
+            pytz.timezone("Europe/Paris").localize(last_record.date)
+        print(last_record.waiting_time)
+        db.add(last_record)
+        db.commit()
+        db.refresh(last_record)
+        return schemas.CollaborativeRecords(**last_record.__dict__)
+
+    raise HTTPException(status_code=406, detail="Client already registered")
+
+
+def delete_collaborative_record(id: int, db: Session):
+    if id == 0:
+        db.query(models.CollaborativeRecords).delete()
+    else:
+        db.query(models.CollaborativeRecords).filter(
+            models.CollaborativeRecords.id == id).delete()
+    db.commit()
+    return