new age with tortole user works but not tests

.gitignore

@@ -0,0 +1,2 @@
+*.pyc
+*sqlite3*

.gitpod.yml

@@ -0,0 +1,10 @@
+# This configuration file was automatically generated by Gitpod.
+# Please adjust to your needs (see https://www.gitpod.io/docs/introduction/learn-gitpod/gitpod-yaml)
+# and commit this file to your remote git repository to share the goodness with others.
+
+# Learn more from ready-to-use templates: https://www.gitpod.io/docs/introduction/getting-started/quickstart
+
+tasks:
+  - init: pip install -r requirements.txt
+
+

App/CommentLikes/CommentLikesRoutes.py

@@ -1,12 +0,0 @@
-from fastapi import APIRouter, status
-from .Schemas import BaseRequest, editRequest
-from .Model import Comments
-from App.Users.Model import User
-from App.Post.Model import Post
-
-commentLikes_router = APIRouter(tags=["CommentLikes"])
-
-
-@commentLikes_router.get("/likes/comments/add")
-async def add_commentLike():
-    pass

App/CommentLikes/Model.py

@@ -1,19 +0,0 @@
-import asyncio
-import orm
-import psycopg2
-import datetime
-import pydantic
-from App.modelInit import database, models
-from App.Users.Model import User
-from App.Post.Model import Post
-
-
-class CommentLike(orm.Model):
-    tablename = "commentlikes"
-    registry = models
-    fields = {
-        "id": orm.Integer(primary_key=True),
-        "user": orm.ForeignKey(User, on_delete=orm.CASCADE),
-        "post": orm.ForeignKey(Post, on_delete=orm.CASCADE),
-        "createdAt": orm.DateTime(index=True, default=datetime.datetime.now),
-    }

App/CommentLikes/Schemas.py

@@ -1,14 +0,0 @@
-from typing import List, Optional
-from pydantic import EmailStr, BaseModel
-from datetime import date, datetime, time, timedelta
-
-
-class addLike(BaseModel):
-    postId: int
-    userId: int
-
-
-class deleteLike(BaseModel):
-    id: int
-    postId: int
-    userId: int

App/Comments/CommentRoutes.py

@@ -1,51 +0,0 @@
-from fastapi import APIRouter, status
-from .Schemas import createComment, editComment, deleteComment, allComments
-from .Model import Comment
-from App.Users.Model import User
-from App.Post.Model import Post
-from App.utils import get_user_and_post
-import asyncio
-
-postLike_router = APIRouter(tags=["PostLikes"])
-
-
-comment_router = APIRouter(tags=["Comments"])
-
-
-@comment_router.post("/comment/create")
-async def create_comment(comment: createComment):
-    user, _post = await get_user_and_post(comment)
-    data = await Comment.objects.create(user=user, content=comment.content, post=_post)
-    return {"code": 200, "message": "success", "payload": data.__dict__}
-
-
-@comment_router.post("/comment/edit")
-async def edit_comment(comment: editComment):
-    # user,_post = await get_user_and_post(comment)
-    db_comment = await Comment.objects.filter(id=comment.id).first()
-    if not db_comment:
-        return {"code": 400, "message": "Comment does not exist", "payload": None}
-    if db_comment.user.id != comment.userId:
-        return {
-            "code": 400,
-            "message": "This comment belongs to a different user",
-            "payload": None,
-        }
-    db_data = await db_comment.update(content=comment.content)
-    return {"code": 200, "message": "success", "payload": None}
-
-
-@comment_router.post("/comment/all")
-async def all_comments(comment: allComments):
-    user = await User.objects.filter(id=comment.userId).first()
-    if not user:
-        return {"code": 400, "message": "User does not exist", "payload": None}
-    db_comment = await Comment.objects.filter(user=user).all()
-
-    if not db_comment:
-        return {"code": 400, "message": "Comment does not exist", "payload": None}
-    return {
-        "code": 200,
-        "message": "success",
-        "payload": [i.__dict__ for i in db_comment],
-    }

App/Comments/Model.py

@@ -1,21 +0,0 @@
-import asyncio
-import orm
-import psycopg2
-import datetime
-import pydantic
-from App.modelInit import database, models
-from App.Users.Model import User
-
-
-class Comment(orm.Model):
-    tablename = "comments"
-    registry = models
-    fields = {
-        "id": orm.Integer(primary_key=True),
-        "user": orm.ForeignKey(User, on_delete=orm.CASCADE),
-        "post": orm.ForeignKey(User, on_delete=orm.CASCADE),
-        "content": orm.String(max_length=100),
-        "likes": orm.Integer(index=True, default=0),
-        "createdAt": orm.DateTime(index=True, default=datetime.datetime.now),
-        "updatedAt": orm.DateTime(index=True, default=datetime.datetime.now),
-    }

App/Comments/Schemas.py

@@ -1,26 +0,0 @@
-from typing import List, Optional
-from pydantic import EmailStr, BaseModel
-from datetime import date, datetime, time, timedelta
-
-
-class createComment(BaseModel):
-    userId: int
-    content: str
-    postId: int
-
-
-class editComment(BaseModel):
-    id: int
-    userId: int
-    content: str
-    postId: int
-
-
-class deleteComment(BaseModel):
-    id: int
-    userId: int
-    postId: int
-
-
-class allComments(BaseModel):
-    userId: int

App/Post/Model.py

@@ -1,19 +0,0 @@
-import asyncio
-import orm
-import psycopg2
-import datetime
-import pydantic
-from App.modelInit import database, models
-from App.Users.Model import User
-
-
-class Post(orm.Model):
-    tablename = "posts"
-    registry = models
-    fields = {
-        "id": orm.Integer(primary_key=True),
-        "pageId": orm.Integer(index=True, default=0),
-        "content": orm.JSON(),
-        "recommendations": orm.JSON(allow_null=True),
-        "createdAt": orm.DateTime(index=True, default=datetime.datetime.now),
-    }

App/Post/PostRoutes.py

@@ -1,30 +0,0 @@
-from fastapi import APIRouter, status
-from .Schemas import createPost, editPost, getPost
-from .Model import Post
-
-post_router = APIRouter(tags=["Posts"])
-
-
-@post_router.post("/post/create")
-async def create_post(post: createPost):
-    data = await Post.objects.create(**post.dict())
-    return {"code": 200, "message": "success", "payload": data.__dict__}
-
-
-@post_router.post("/post/update")
-async def create_post(post: editPost):
-    temp = await Post.objects.get(id=post.id)
-    data = await temp.update(recommendations=post.recommendations, content=post.content)
-    # data=await Post.objects.update(**post.dict())
-    return {"code": 200, "message": "success", "payload": temp.__dict__}
-
-
-@post_router.post("/post/get")
-async def create_post(post: getPost):
-    data = await Post.objects.get(id=post.id)
-    return {"code": 200, "message": "success", "payload": data.__dict__}
-
-@post_router.post("/post/delete_all")
-async def create_post():
-    data = await Post.objects.delete()
-    return {"code": 200, "message": "success", "payload": data.__dict__}

App/Post/Schemas.py

@@ -1,19 +0,0 @@
-from typing import List, Optional
-from pydantic import EmailStr, BaseModel
-from datetime import date, datetime, time, timedelta
-
-
-class editPost(BaseModel):
-    id: Optional[int]
-    content: Optional[dict]
-    recommendations: Optional[dict]
-
-
-class createPost(BaseModel):
-    pageId:int
-    content: Optional[dict]
-    recommendations: Optional[dict]
-
-
-class getPost(BaseModel):
-    id: Optional[int]

App/PostLikes/Model.py

@@ -1,19 +0,0 @@
-import asyncio
-import orm
-import psycopg2
-import datetime
-import pydantic
-from App.modelInit import database, models
-from App.Users.Model import User
-from App.Post.Model import Post
-
-
-class PostLike(orm.Model):
-    tablename = "postlikes"
-    registry = models
-    fields = {
-        "id": orm.Integer(primary_key=True),
-        "user": orm.ForeignKey(User, on_delete=orm.CASCADE),
-        "post": orm.ForeignKey(Post, on_delete=orm.CASCADE),
-        "createdAt": orm.DateTime(index=True, default=datetime.datetime.now),
-    }

App/PostLikes/PostLikesRoutes.py

@@ -1,43 +0,0 @@
-from fastapi import APIRouter, Depends
-from .Schemas import addLike, deleteLike
-from .Model import PostLike
-from App.Users.Model import User
-from App.Post.Model import Post
-from App.utils import get_user_and_post
-import asyncio
-
-postLike_router = APIRouter(tags=["PostLikes"])
-
-
-@postLike_router.post("/postLike/add")
-async def add_postLike(post: addLike):
-    user, _post = await get_user_and_post(
-        post
-    )  # validate if both the post and user exist
-    previos = await PostLike.objects.filter(user=user).filter(post=_post).first()
-    if previos:
-        return {"code": 400, "message": "you already liked it", "payload": None}
-
-    data = await PostLike.objects.create(post=_post, user=user)
-    return {"code": 200, "message": "success", "payload": data.__dict__}
-
-
-@postLike_router.post("/postLike/delete")
-async def create_post(post: deleteLike):
-    user, _post = await get_user_and_post(post)
-    data = await PostLike.objects.filter(id=post.id).first()
-    if not data:
-        return {"code": 400, "message": "Does not exist", "payload": None}
-    if user.id == data.user.id and _post.id == data.post.id:
-        await data.delete()
-        return {"code": 200, "message": "success", "payload": None}
-
-
-@postLike_router.post("/postLike/get")
-async def create_post(post: deleteLike):
-    user, _post = await get_user_and_post(post)
-    data = await PostLike.objects.filter(id=post.id).first()
-    if not data:
-        return {"code": 400, "message": "Does not exist", "payload": None}
-    if user.id == data.user.id and _post.id == data.post.user.id:
-        return {"code": 200, "message": "success", "payload": data.__dict__}

App/PostLikes/Schemas.py

@@ -1,14 +0,0 @@
-from typing import List, Optional
-from pydantic import EmailStr, BaseModel
-from datetime import date, datetime, time, timedelta
-
-
-class addLike(BaseModel):
-    postId: int
-    userId: int
-
-
-class deleteLike(BaseModel):
-    id: int
-    postId: int
-    userId: int

App/Tests/test_user_routes.py

@@ -0,0 +1,58 @@
+import pytest
+from httpx import AsyncClient
+from App.app import app  # Assuming app.py initializes and configures the FastAPI instance
+
+# Define test user data
+test_user = {
+    "name": "Testasd User",
+    "email": "[email protected]",
+    "password": "strongasdpassword123",
+    "phoneNumber": "1234897890",
+  "mac_address": "strdding"}
+
+reset_password_data = {
+    "phoneNumber": "1234897890",
+    "new_password": "newpassword123"
+}
+
+@pytest.mark.asyncio
+async def test_register_user():
+    async with AsyncClient(app=app, base_url="https://8000-mboneaewall-templatebac-t1vqae3xohv.ws-eu116.gitpod.io/") as client:
+        response = await client.post("/user/register", json=test_user)
+    assert response.status_code == 201
+    assert response.json()["code"] == 200
+    assert response.json()["message"] == "User created successfully"
+
+@pytest.mark.asyncio
+async def test_login_user():
+    async with AsyncClient(app=app, base_url="https://8000-mboneaewall-templatebac-t1vqae3xohv.ws-eu116.gitpod.io/") as client:
+        login_data = {"phoneNumber": test_user["phoneNumber"], "password": test_user["password"],"mac_address": "strdding"}
+        response = await client.post("/user/login", data=login_data)
+    assert response.status_code == 200
+    assert "access_token" in response.json()
+
+@pytest.mark.asyncio
+async def test_forgot_password():
+    async with AsyncClient(app=app, base_url="https://8000-mboneaewall-templatebac-t1vqae3xohv.ws-eu116.gitpod.io/") as client:
+        response = await client.post("/user/forgot-password", json={"phoneNumber": test_user["phoneNumber"]})
+    assert response.status_code == 200
+    assert response.json()["code"] == 200
+    assert response.json()["message"] == "Password reset token sent. Check your phone for further instructions."
+
+@pytest.mark.asyncio
+async def test_verify_reset_token():
+    async with AsyncClient(app=app, base_url="https://8000-mboneaewall-templatebac-t1vqae3xohv.ws-eu116.gitpod.io/") as client:
+        # Mock the reset token for testing (this would typically be retrieved from the response)
+        verify_data = {"phoneNumber": test_user["phoneNumber"], "reset_token": "123456"}
+        response = await client.post("/user/verify-reset-token", json=verify_data)
+    assert response.status_code == 200
+    assert response.json()["code"] == 200
+    assert response.json()["message"] == "Token verified. You may now reset your password."
+
+@pytest.mark.asyncio
+async def test_reset_password():
+    async with AsyncClient(app=app, base_url="https://8000-mboneaewall-templatebac-t1vqae3xohv.ws-eu116.gitpod.io/") as client:
+        response = await client.post("/user/reset-password", json=reset_password_data)
+    assert response.status_code == 200
+    assert response.json()["code"] == 200
+    assert response.json()["message"] == "Password has been reset successfully."

App/Users/Model.py

@@ -1,28 +1,76 @@
 import asyncio
-import orm
-import psycopg2
-import datetime
-import pydantic
+import uuid
+from tortoise import fields, Tortoise
+from tortoise.models import Model
 from passlib.context import CryptContext
-from App.modelInit import database, models
-
+import datetime
+import random
+import string
 pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")
 
+def generate_short_uuid() -> str:
+    """Generate a random 5-character alphanumeric string."""
+    return ''.join(random.choices(string.ascii_letters + string.digits, k=5))
+
+
+class User(Model):
+    id = fields.CharField(primary_key=True, max_length=5, default=generate_short_uuid)
+    name = fields.CharField(max_length=100, db_index=True)
+    email = fields.CharField(max_length=100, db_index=True, unique=True)
+    password = fields.CharField(max_length=100)
+    phoneNumber = fields.CharField(max_length=100, null=True)
+    account_type = fields.IntField(default=1)
+    balance = fields.DecimalField(max_digits=10, decimal_places=2, default=0.00)
+    ip_address = fields.CharField(max_length=45, null=True)
+    mac_address = fields.CharField(max_length=17, null=True)
+    createdAt = fields.DatetimeField(default=datetime.datetime.now)
+    updatedAt = fields.DatetimeField(default=datetime.datetime.now)
+    lastLogin = fields.DatetimeField(default=datetime.datetime.now)
+    failed_attempts = fields.IntField(default=0)
+    account_locked = fields.BooleanField(default=False)
+    reset_token = fields.CharField(max_length=100, null=True, unique=True)
+    reset_token_expiration = fields.DatetimeField(null=True)
+
+    class Meta:
+        table = "users"
+
+    def verify_password(self, plain_password: str) -> bool:
+        if self.account_locked:
+            print("Account is locked due to too many failed attempts.")
+            return False
+
+        if pwd_context.verify(plain_password, self.password):
+            self.failed_attempts = 0  # Reset failed attempts on success
+            self.account_locked = False
+            self.save()  # Save changes to reset the failed attempts count
+            return True
+        else:
+            self.failed_attempts += 1
+            if self.failed_attempts >= 5:
+                self.account_locked = True
+                print("Account locked due to too many failed attempts.")
+            self.save()  # Save changes to update the failed attempts count
+            return False
+
+    async def initiate_password_reset(self):
+        # Generate a unique reset token
+        self.reset_token = str(uuid.uuid4())
+        self.reset_token_expiration = datetime.datetime.now() + datetime.timedelta(hours=1)  # Token expires in 1 hour
+        await self.save()
+
+        # In a real application, send this token to the user's email or phone
+        print(f"Password reset token for {self.email}: {self.reset_token}")
+
+    async def reset_password(self, reset_token, new_password):
+        # Check if the reset token is valid and not expired
+        if self.reset_token != reset_token or datetime.datetime.now() > self.reset_token_expiration:
+            print("Invalid or expired reset token.")
+            return False
 
-class User(orm.Model):
-    tablename = "users"
-    registry = models
-    fields = {
-        "id": orm.Integer(primary_key=True),
-        "name": orm.String(max_length=100, index=True),
-        "email": orm.String(max_length=100, index=True, unique=True),
-        "password": orm.String(max_length=100, index=True),
-        "phoneNumber": orm.String(max_length=100, index=True, allow_null=True),
-        "account_type": orm.Integer(index=True, default=1),
-        "createdAt": orm.DateTime(index=True, default=datetime.datetime.now),
-        "updatedAt": orm.DateTime(index=True, default=datetime.datetime.now),
-        "lastLogin": orm.DateTime(index=True, default=datetime.datetime.now),
-    }
-
-    def verify_password(self, plain_password):
-        return pwd_context.verify(plain_password, self.password)
+        # Set the new password
+        self.password = pwd_context.hash(new_password)
+        self.reset_token = None  # Clear the token after successful reset
+        self.reset_token_expiration = None
+        await self.save()
+        print("Password has been reset successfully.")
+        return True

App/Users/Schemas.py

@@ -1,15 +1,99 @@
-from typing import List, Optional
-from pydantic import EmailStr, BaseModel
+from pydantic import BaseModel, Field, constr
+from typing import Optional
+from datetime import datetime
 from passlib.context import CryptContext
 
 pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")
 
 
-class BaseRequest(BaseModel):
-    email: EmailStr
-    name: str
-    password: str
-    phoneNumber: Optional[str]
-
+# Register User Request
+class RegisterUserRequest(BaseModel):
+    name: str = Field(..., max_length=100)
+    email: str = Field(..., max_length=100)
+    password: constr(min_length=8)
+    phoneNumber: str = Field(..., max_length=15)
+    mac_address: str = Field(..., max_length=17)  # Standard MAC address format
     def hash_password(self):
         self.password = pwd_context.hash(self.password)
+    class Config:
+        schema_extra = {
+            "example": {
+                "name": "John Doe",
+                "email": "[email protected]",
+                "password": "strongpassword123",
+                "phoneNumber": "1234567890",
+                "mac_address": "00:1A:2B:3C:4D:5E"
+            }
+        }
+
+
+# Login User Request (using phone number and MAC address)
+class LoginUserRequest(BaseModel):
+    phoneNumber: str = Field(..., max_length=15)
+    password: constr(min_length=8)
+    mac_address: str = Field(..., max_length=17)  # Required for login
+
+    class Config:
+        schema_extra = {
+            "example": {
+                "phoneNumber": "1234567890",
+                "password": "strongpassword123",
+                "mac_address": "00:1A:2B:3C:4D:5E"
+            }
+        }
+
+
+# Access Token Response (used for Login)
+class AccessTokenResponse(BaseModel):
+    access_token: str
+    token_type: str = "bearer"
+
+
+# Base Response Schema
+class BaseResponse(BaseModel):
+    code: int
+    message: str
+    payload: Optional[dict] = None
+
+# Schemas.py
+
+
+
+# Step 1: Forgot Password Request (using phone number)
+class ForgotPasswordRequest(BaseModel):
+    phoneNumber: str = Field(..., max_length=15)
+
+    class Config:
+        schema_extra = {
+            "example": {
+                "phoneNumber": "1234567890"
+            }
+        }
+
+
+# Step 2a: Verify Reset Token Request
+class VerifyResetTokenRequest(BaseModel):
+    phoneNumber: str = Field(..., max_length=15)
+    reset_token: str = Field(..., max_length=6)  # Short token
+
+    class Config:
+        schema_extra = {
+            "example": {
+                "phoneNumber": "1234567890",
+                "reset_token": "123456"
+            }
+        }
+
+
+# Step 2b: Reset Password Request (after token verification)
+class ResetPasswordRequest(BaseModel):
+    phoneNumber: str = Field(..., max_length=15)
+    new_password: constr(min_length=8)
+
+    class Config:
+        schema_extra = {
+            "example": {
+                "phoneNumber": "1234567890",
+                "new_password": "newstrongpassword123"
+            }
+        }

App/Users/UserRoutes.py

@@ -1,28 +1,105 @@
-from fastapi import APIRouter, status
-from .Schemas import BaseRequest
+from fastapi import APIRouter, HTTPException, status
+from .Schemas import (
+    RegisterUserRequest, ResetPasswordRequest, LoginUserRequest,
+    AccessTokenResponse, BaseResponse, ForgotPasswordRequest, VerifyResetTokenRequest
+)
 from .Model import User
-from sqlalchemy import and_
-from fastapi.security import OAuth2PasswordBearer, OAuth2PasswordRequestForm
+from jose import jwt
+from datetime import datetime, timedelta,timezone
+import random
+from passlib.context import CryptContext
 
-oauth_scheme = OAuth2PasswordBearer(tokenUrl="/user/login")
+# Configurations for JWT and Password Reset
+SECRET_KEY = "your_secret_key_here"
+ALGORITHM = "HS256"
+ACCESS_TOKEN_EXPIRE_MINUTES = 30
+PASSWORD_RESET_EXPIRE_MINUTES = 15  # Reset token valid for 15 minutes
+
+pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")
 user_router = APIRouter(tags=["User"])
 
+# Utility function to create JWT token
+def create_access_token(data: dict, expires_delta: timedelta = None):
+    to_encode = data.copy()
+    expire = datetime.utcnow() + (expires_delta or timedelta(minutes=ACCESS_TOKEN_EXPIRE_MINUTES))
+    to_encode.update({"exp": expire})
+    return jwt.encode(to_encode, SECRET_KEY, algorithm=ALGORITHM)
+
+# Register route
+@user_router.post("/user/register", response_model=BaseResponse, status_code=status.HTTP_201_CREATED)
+async def register_user(user: RegisterUserRequest):
+    existing_user = await User.filter(phoneNumber=user.phoneNumber).first()
+    if existing_user:
+        raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail="User already exists.")
+
+    user.hash_password()
+    new_user = await User.create(**user.dict())
+    return BaseResponse(code=200, message="User created successfully", payload={"user_id": new_user.id})
+
+# Login route (using phone number)
+@user_router.post("/user/login", response_model=AccessTokenResponse, status_code=status.HTTP_200_OK)
+async def login_user(user: LoginUserRequest):
+    db_user = await User.filter(phoneNumber=user.phoneNumber).first()
+    if db_user and db_user.verify_password(user.password):
+        access_token = create_access_token(data={"sub": db_user.phoneNumber})
+        return AccessTokenResponse(access_token=access_token, token_type="bearer")
+    
+    raise HTTPException(
+        status_code=status.HTTP_401_UNAUTHORIZED,
+        detail="Invalid credentials",
+        headers={"WWW-Authenticate": "Bearer"},
+    )
+
+# Forgot Password route (using phone number only)
+@user_router.post("/user/forgot-password", response_model=BaseResponse, status_code=status.HTTP_200_OK)
+async def forgot_password(request: ForgotPasswordRequest):
+    user = await User.filter(phoneNumber=request.phoneNumber).first()
+    if not user:
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="User not found.")
+
+    # Generate a short reset token (6-digit code)
+    reset_token = f"{random.randint(100000, 999999)}"
+    reset_token_expiration = datetime.utcnow() + timedelta(minutes=PASSWORD_RESET_EXPIRE_MINUTES)
+    
+    # Store reset token and expiration in the user record
+    user.reset_token = reset_token
+    user.reset_token_expiration = reset_token_expiration
+    await user.save()
+
+    # In production, send this token via SMS to the user's phone number
+    print(f"Password reset token for {request.phoneNumber}: {reset_token}")
+
+    return BaseResponse(code=200, message="Password reset token sent. Check your phone for further instructions.")
+
+# Verify Reset Token route
+@user_router.post("/user/verify-reset-token", response_model=BaseResponse, status_code=status.HTTP_200_OK)
+async def verify_reset_token(request: VerifyResetTokenRequest):
+    user = await User.filter(phoneNumber=request.phoneNumber, reset_token=request.reset_token).first()
+    if not user:
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Invalid token or phone number.")
+
+    # Check if the reset token has expired
+    if datetime.utcnow().replace(tzinfo=timezone.utc) > user.reset_token_expiration:
+        raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail="Reset token has expired.")
+
+    return BaseResponse(code=200, message="Token verified. You may now reset your password.")
+
+# Reset Password route (After Token Verification)
+@user_router.post("/user/reset-password", response_model=BaseResponse, status_code=status.HTTP_200_OK)
+async def reset_password(request: ResetPasswordRequest):
+    user = await User.filter(phoneNumber=request.phoneNumber).first()
+    if not user:
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="User not found.")
+
+    # Check if the reset token is present and not expired
+
+    if not user.reset_token or datetime.utcnow().replace(tzinfo=timezone.utc) > user.reset_token_expiration:
+        raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail="Reset token invalid or expired.")
+
+    # Update the user's password and clear the reset token
+    user.password = pwd_context.hash(request.new_password)
+    user.reset_token = None
+    user.reset_token_expiration = None
+    await user.save()
 
-@user_router.post("/user/register")
-async def register_user(user: BaseRequest):
-    data = await User.objects.filter(email=user.email).first()
-    if data != None:
-        return {"code": 400, "message": "user exists", "payload": None}
-    else:
-        user.hash_password()
-    sample = await User.objects.create(**user.dict())
-    return {"code": 200, "message": "success", "payload": None}
-
-
-@user_router.post("/user/login")
-async def register_user(user: BaseRequest):
-    db_user = await User.objects.filter(email=user.email).first()
-    if db_user:
-        if  db_user.verify_password(user.password):
-            return {"code": 200, "message": "success", "payload": db_user.__dict__}
-    return {"code": 401, "message": "Invalid Credentials", "payload": None}
+    return BaseResponse(code=200, message="Password has been reset successfully.")

App/app.py

@@ -1,19 +1,15 @@
 from fastapi import FastAPI
+from tortoise import Tortoise, run_async
 from .Users.UserRoutes import user_router
-from .Post.PostRoutes import post_router
-from .PostLikes.PostLikesRoutes import postLike_router
-from .Comments.CommentRoutes import comment_router
-from .modelInit import models, database
+from .modelInit import TORTOISE_ORM
 
 app = FastAPI()
 
 
 @app.on_event("startup")
 async def startup_event():
-    await models.create_all()
-    if not database.is_connected:
-        await database.connect()
-        print("connected!")
+    await Tortoise.init(config=TORTOISE_ORM)
+    await Tortoise.generate_schemas()
 
 
 @app.get("/")
@@ -22,9 +18,7 @@ async def landing_page():
 
 
 app.include_router(user_router)
-app.include_router(comment_router)
-app.include_router(post_router)
-app.include_router(postLike_router)
+
 
 
 async def main():

App/discovery.py

@@ -0,0 +1,25 @@
+# discover_models.py
+
+import importlib
+import os
+from typing import List
+
+def discover_models(target_file: str,directory: str="./") -> List[str]:
+    """
+    Discover target file (e.g., models.py) in all directories and subdirectories.
+    
+    :param directory: The root directory to start searching from.
+    :param target_file: The filename to look for in subdirectories (e.g., "models.py").
+    :return: A list of module paths as strings.
+    """
+    model_modules = []
+    
+    # Traverse directory and subdirectories
+    for root, _, files in os.walk(directory):
+        if target_file in files:
+            # Construct the module path, converting file path to dot notation
+            relative_path = os.path.relpath(root, directory)
+            module_name = f"{directory.replace('/', '.')}.{relative_path.replace('/', '.')}.{target_file[:-3]}"
+            model_modules.append(module_name.replace('...',""))
+    print(model_modules)
+    return model_modules

App/modelInit.py

@@ -1,6 +1,16 @@
-import databases
-import orm
-import psycopg2
+from App.discovery import discover_models
+
+DATABASE_URL = "sqlite://db.sqlite3"  # Example: SQLite for local development
+
+TORTOISE_ORM = {
+    "connections": {"default": DATABASE_URL},
+    "apps": {
+        "models": {
+            "models": discover_models("Model.py"),  # Automatically discover models in the "models" directory
+            "default_connection": "default",
+        }
+    },
+}
 
 # HOST=aws.connect.psdb.cloud
 # USERNAME=kn9rzjlad1tw8bvojqg9
@@ -8,9 +18,9 @@ import psycopg2
 # DATABASE=movie-website
 
 
-database = databases.Database(
-    "postgresql+asyncpg://postgres:[email protected]:5432/postgres"
-)
+# database = databases.Database(
+#     "postgresql+asyncpg://postgres:[email protected]:5432/postgres"
+# )
 # database = databases.Database(
 #     "postgresql+asyncpg://user:password@db:5432/mydatabase"
 # )
@@ -22,4 +32,4 @@ database = databases.Database(
 
 
 # databases = databases.Database(**args)
-models = orm.ModelRegistry(database=database)
+

requirements.txt

@@ -1,20 +1,8 @@
-asyncpg==0.27.0
-click==8.1.3
-databases==0.7.0
-fastapi==0.92.0
-Flask==2.2.2
-greenlet==2.0.2
-itsdangerous==2.1.2
-orm==0.3.1
-psycopg2-binary==2.9.5
-SQLAlchemy==1.4.46
-starlette==0.25.0
-typesystem==0.3.1
-Werkzeug==2.2.2
-passlib                # for password hashing
+fastapi
+passlib
 pydantic[email]
-uvicorn==0.21.1
-gunicorn
-orm[mysql]
-python-multipart
-asyncmy
+uvicorn
+jose
+httpx
+pytest
+tortoise-orm