Upload 4 files

users/models.py

@@ -0,0 +1,32 @@
+from sqlalchemy import Boolean, Column, ForeignKey, Integer, String, Float, ARRAY, DateTime
+from sqlalchemy.orm import relationship
+from core.database import Base
+from datetime import datetime
+
+class User(Base):
+    __tablename__ = "users"
+
+    id = Column(Integer, primary_key=True, index=True)
+    email = Column(String, unique=True, index=True)
+    username = Column(String, unique=True, index=True)
+    hashed_password = Column(String)
+    first_name = Column(String)
+    last_name = Column(String)
+    age = Column(Integer)
+    preferences = Column(ARRAY(String))
+    is_active = Column(Boolean, default=True)
+    is_admin = Column(Boolean, default=False)
+    updated_at = Column(DateTime, default=datetime.utcnow)
+    created_at = Column(DateTime, default=datetime.utcnow)
+
+    orders = relationship("Order", back_populates="user")
+    embeddings = relationship("UserEmbeddings", back_populates="user", uselist=False)
+
+class UserEmbeddings(Base):
+    __tablename__ = "user_embeddings"
+
+    id = Column(Integer, primary_key=True, index=True)
+    user_id = Column(Integer, ForeignKey("users.id"))
+    embeddings = Column(ARRAY(Float))
+
+    user = relationship("User", back_populates="embeddings")

users/routes.py

@@ -0,0 +1,125 @@
+from fastapi import APIRouter, status, Depends, Request, UploadFile, File, HTTPException
+from fastapi.responses import JSONResponse
+from sqlalchemy.orm import Session
+from core.database import get_db
+from core.security import get_current_user, create_access_token
+from users.schemas import UserCreate, UserBase, UserEmbeddingsBase, User
+from users.services import create_user_account, create_user_embeddings, update_user, update_user_embeddings, get_user_by_id, get_user_by_email
+from services.facial_processing import FacialProcessing
+from services.face_match import FaceMatch
+import os
+from datetime import timedelta
+from dotenv import load_dotenv
+from auth.services import get_token
+
+
+env_path = (os.path.abspath(os.path.join(os.path.dirname(__file__), '.env')))
+load_dotenv()
+
+router = APIRouter(
+    prefix="/users",
+    tags=["Users"],
+    responses={404: {"description": "Not found"}},
+)
+
+@router.get("/health", tags=["Health"])
+def health_check():
+    return {"status": "ok"}
+
+@router.post("/", status_code=status.HTTP_201_CREATED, response_model=UserBase)
+async def create_user(data: UserCreate, db: Session = Depends(get_db)):
+    await create_user_account(data, db)
+    payload = {"message": "User created successfully"}
+    return JSONResponse(content=payload, status_code=status.HTTP_201_CREATED)
+
+
+@router.post("/me",status_code=status.HTTP_200_OK)
+def get_user_details(request: Request):
+    user = request.user
+    return user
+
+@router.get("/me", response_model=UserBase)
+async def read_users_me(current_user: User = Depends(get_current_user)):
+    return current_user
+
+@router.put("/me", response_model=UserBase)
+async def updating_user(user: UserBase, current_user: User = Depends(get_current_user), db: Session = Depends(get_db)):
+    user = update_user(db, current_user.id, user)
+    return current_user
+
+
+@router.post("/me/face",status_code=status.HTTP_200_OK)
+async def create_face_embeddings(file: UploadFile = File(...), user:User = Depends(get_current_user), db: Session = Depends(get_db)):
+    face_processor = FacialProcessing()
+
+    # Process the uploaded image
+    image_path = f"faces/{user.id}.jpg"
+    with open(image_path, "wb") as buffer:
+        buffer.write(await file.read())
+
+    # Extract embeddings
+    embeddings = face_processor.extract_embeddings_vgg(image_path)
+    if embeddings:
+        create_user_embeddings(user.id, embeddings, db)
+        return {"message": "Face embeddings created successfully"}
+
+    raise HTTPException(status_code=400,
+                        detail="Failed to process face"
+                        )
+
+@router.get("/me/face",status_code=status.HTTP_200_OK)
+async def get_face_embeddings(user:User = Depends(get_current_user), db: Session = Depends(get_db)):
+    face = db.query(UserEmbeddingsBase).filter(UserEmbeddingsBase.user_id == user.id).first()
+    if not face:
+        raise HTTPException(status_code=404,
+                            detail="Face embeddings not found"
+                            )
+    return JSONResponse(content={"embeddings": face.embeddings}, status_code=status.HTTP_200_OK)
+
+@router.put("/me/face",status_code=status.HTTP_200_OK)
+async def updating_face_embeddings(file: UploadFile = File(...), user:User = Depends(get_current_user), db: Session = Depends(get_db)):
+    face_processor = FacialProcessing()
+
+    # Process the uploaded image
+    image_path = f"faces/{user.id}.jpg"
+    with open(image_path, "wb") as buffer:
+        buffer.write(await file.read())
+
+    # Extract embeddings
+    embeddings = face_processor.extract_embeddings_vgg(image_path)
+    if embeddings:
+        update_user_embeddings(user.id, embeddings, db)
+        return {"message": "Face embeddings updated successfully"}
+
+    raise HTTPException(status_code=400,
+                        detail="Failed to process face"
+                        )
+
+@router.post("/login/face")
+async def face_login(file: UploadFile = File(...), db: Session = Depends(get_db)):
+    face_processor = FacialProcessing()
+    face_matcher = FaceMatch(db)
+
+    # Process the uploaded image
+    image_path = f"temp_{file.filename}"
+    with open(image_path, "wb") as buffer:
+        buffer.write(await file.read())
+
+    # Extract embeddings
+    embeddings = await face_processor.extract_embeddings(image_path)
+    if not embeddings:
+        raise HTTPException(status_code=400, detail="Failed to process face")
+    
+    # Match face
+    match_result = face_matcher.new_face_matching(embeddings)
+    if match_result['status'] == 'Success':
+        user = get_user_by_id(match_result['user_id'], db)
+        if not user:
+            raise HTTPException(status_code=404, detail="User not found")
+        
+        access_token_expires = timedelta(minutes=os.getenv("ACCESS_TOKEN_EXPIRE_MINUTES"))
+        payload = {"id":user.id, "sub": user.email}
+        token = get_token(payload, db)
+        return JSONResponse(content=token.dict(), status_code=status.HTTP_200_OK)
+    
+    raise HTTPException(status_code=401, detail="Face not recognized")

users/schemas.py

@@ -0,0 +1,40 @@
+from pydantic import BaseModel, EmailStr
+from typing import Optional, List
+
+class UserBase(BaseModel):
+    username: str
+    first_name: str
+    last_name: str
+    email: EmailStr
+    age: Optional[int] = None
+    preferences: Optional[dict] = None
+    is_active: Optional[bool] = True
+
+
+class UserCreate(UserBase):
+    password: str
+
+
+class UserUpdate(UserBase):
+    password: Optional[str] = None
+
+class User(UserBase):
+    id: int
+
+    class Config:
+        orm_mode = True
+
+class UserEmbeddingsBase(BaseModel):
+    embeddings: List[float]
+
+class UserEmbeddingsCreate(UserEmbeddingsBase):
+    pass
+
+
+class UserEmbeddings(UserEmbeddingsBase):
+    id: int
+    user_id: int
+
+    class Config:
+        orm_mode = True
+

users/services.py

@@ -0,0 +1,84 @@
+from users.models import User, UserEmbeddings
+from fastapi.exceptions import HTTPException
+from core.security import get_password_hash
+from datetime import datetime
+from sqlalchemy.orm import Session
+from users.schemas import UserCreate, UserUpdate, UserEmbeddingsModel
+
+
+async def create_user_account(data:UserCreate, db:Session):
+    user = db.query(User).filter(User.email == data.email).first()
+    if user:
+        raise HTTPException(status_code=422, detail="Email already registered")
+    
+    new_user = User(
+        email=data.email,
+        first_name=data.first_name,
+        last_name=data.last_name,
+        age=data.age,
+        preferences=data.preferences,
+        password = get_password_hash(data.password),
+        registered_at=datetime.now(),
+        updated_at=datetime.now(),   
+    )
+
+    db.add(new_user)
+    db.commit()
+    db.refresh(new_user)
+    return new_user
+
+async def create_user_embeddings(user_id:int, embeddings:UserEmbeddingsModel, db:Session):
+    user = db.query(User).filter(User.id == user_id).first()
+    if not user:
+        embeddings = UserEmbeddings(user_id=user_id, embeddings=embeddings.embeddings)
+        db.add(embeddings)
+        db.commit()
+        db.refresh(embeddings)
+        return embeddings
+        
+def get_user_by_id(user_id, db:Session):
+    return db.query(User).filter(User.id == user_id).first()
+
+
+def get_user_by_email(email, db:Session):
+    return db.query(User).filter(User.email == email).first()
+
+
+def get_users(db:Session, skip=0, limit=100):
+    return db.query(User).offset(skip).limit(limit).all()
+
+
+def update_user(db:Session, user_id:int, user:UserUpdate):
+    user = db.query(User).filter(User.id == user_id).first()
+    if user:
+        update_data = user.dict(exclude_unset=True)
+        if 'password' in update_data:
+            update_data['password'] = get_password_hash(update_data['password'])
+            del update_data['password']
+        
+        for key, value in update_data.items():
+            setattr(user, key, value)
+        db.commit()
+        db.refresh(user)
+    return user
+
+
+def delete_user(user_id, db:Session):
+    user = db.query(User).filter(User.id == user_id).first()
+    if user:
+        db.delete(user)
+        db.commit()
+        return user
+    return None
+
+
+async def update_user_embeddings(user_id:int, embeddings:UserEmbeddingsModel, db:Session):
+    embeddings = db.query(UserEmbeddings).filter(UserEmbeddings.user_id == user_id).first()
+    if embeddings:
+        embeddings.embeddings = embeddings.embeddings
+        db.commit()
+        db.refresh(embeddings)
+        return embeddings
+    return None
+
+