Add application file

.env

@@ -0,0 +1,13 @@
+DB_HOST = boovngmcolkrlajvvjia-mysql.services.clever-cloud.com
+DB_USER = umukctgy3i8noafv
+DB_PASSWORD = wqSy96POmhKjWfeOYt8j
+DB_NAME = boovngmcolkrlajvvjia
+# ---------------------------------------------------------------
+# DB_HOST = localhost
+# DB_USER = root
+# DB_PASSWORD = ""
+# DB_NAME = barberia
+DB_PORT = 3306
+ALGORITHM=HS256
+
+SECRET_KEY = roman456alexand3r

.gitignore

@@ -0,0 +1 @@
+__pycache__/

Dockerfile

@@ -0,0 +1,11 @@
+FROM python:3.9
+
+WORKDIR /code
+
+COPY ./requirements.txt /code/requirements.txt
+
+RUN pip install --no-cache-dir --upgrade -r /code/requirements.txt
+
+COPY . .
+
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]

core/config.py

@@ -0,0 +1,27 @@
+from dotenv import load_dotenv
+import os
+
+# Obtener la ruta al archivo .env
+dotenv_path = os.path.join(os.path.dirname(__file__),'..','.env')
+
+# Cargar variables de entorno desde el archivo .env
+load_dotenv(dotenv_path)
+
+class Settings:
+    PROJECT_NAME: str = "Barber-Shop"
+    PROJECT_VERSION: str = "0.0.1"
+    PROJECT_DESCRIPTION: str = "Aplicacion para administrar los ingresos de una barberia"
+    
+    DB_HOST: str = os.getenv("DB_HOST")
+    DB_USER: str = os.getenv("DB_USER")
+    DB_PASSWORD: str = os.getenv("DB_PASSWORD")
+    DB_NAME: str = os.getenv("DB_NAME")
+    DB_PORT: str = os.getenv("DB_PORT",3306) # por defecto
+
+    DATABASE_URL = f"mysql+pymysql://{DB_USER}:{DB_PASSWORD}@{DB_HOST}:{DB_PORT}/{DB_NAME}"
+
+    SECRET_KEY:str = os.getenv("SECRET_KEY")
+    TOKEN_EXPIRE_MIN = 1200
+    ALGORITHM: str = os.getenv("ALGORITHM")
+
+settings = Settings()

core/seguridad.py

@@ -0,0 +1,35 @@
+from passlib.context import CryptContext
+from datetime import datetime,timedelta
+from jose import JWTError,jwt
+from core.config import settings
+
+# Configurar hashing de contraselas
+pwd_context = CryptContext(schemes=["bcrypt"],deprecated="auto")
+
+# Funcion para generar un hash_passw
+
+def get_hashed_password(password :str):
+    return pwd_context.hash(password)
+
+# Funcion para verificar una contraseña hashada
+def verify_password(plain_password:str,hashed_password:str):
+    return pwd_context.verify(plain_password,hashed_password)
+
+# Crear un token JWT
+def create_access_token(data:dict):
+    to_encode = data.copy()
+    expire = datetime.utcnow() + timedelta(minutes=settings.TOKEN_EXPIRE_MIN)
+    to_encode.update({"exp":expire})
+    encode_jwt = jwt.encode(to_encode, settings.SECRET_KEY, algorithm=settings.ALGORITHM)
+    return encode_jwt
+
+# Funcion para verificar si un token valido
+async def verify_token(token:str):
+    try:
+        payload = jwt.decode(token,settings.SECRET_KEY,algorithms=[settings.ALGORITHM])
+        user:str = payload.get("sub") # obtener identificador de usuario
+        return user
+    except jwt.ExpiredSignatureError: # token expirado
+        return None
+    except JWTError:
+        return None

core/utils.py

@@ -0,0 +1,21 @@
+import secrets
+import string
+
+# Funcion para generar un ID de usuario aleatorio
+def generate_user_id(length = 30):
+    # Caracteres posibles para le ID aleatorio
+    characteres = string.ascii_letters + string.digits
+
+    # Genera un ID aleatorio de la longitud deseada
+    random_id = ''.join(secrets.choice(characteres) for _ in range(length))
+
+    return random_id
+
+list_reserve = ["10:00:00","11:00:00","14:00:00","15:00:00","16:00:00","17:00:00","18:00:00","19:00:00","20:00:00"]
+def get_list_reserve():
+    return list_reserve
+
+def sort_object_by_index(object):
+    sorted_keys = sorted(object.keys())
+    sorted_reservations = {key: object[key] for key in sorted_keys}
+    return sorted_reservations

cruds/MovimientosCrud.py

@@ -0,0 +1,132 @@
+import sys
+from models.MovimientosM import Movimiento
+from fastapi import HTTPException
+from schemas.MovimientosSh import *
+from sqlalchemy.orm import Session
+from datetime import date,datetime,timedelta
+from sqlalchemy import func,between
+
+def create_new_movimiento(movi:MovimientosCreate,id_usuario:str,db:Session):
+    db_movimiento = Movimiento(
+        id_usuario = id_usuario,
+        cuenta = movi.cuenta,
+        tipo_movimiento = movi.tipo_movimiento,
+        fecha = movi.fecha,
+        descripcion = movi.descripcion,
+    )
+
+    try:
+        db.add(db_movimiento)
+        db.commit()
+        db.refresh(db_movimiento)
+        db.close()
+        return db_movimiento
+    except Exception as e :
+        db.rollback()
+        # Imprimir el error en la consola
+        print(f"Error al crear un usuario: {str(e)}",file=sys.stderr)
+        raise HTTPException(status_code=500,detail=f"Error al crear un movimiento: {str(e)} ")
+
+def get_weekly_expenses(db: Session, user_id: str,tipo:str):
+    today = datetime.today()
+    if tipo == "SEMANA":
+        start_week = today - timedelta(days=today.weekday())
+        end_week = start_week + timedelta(days=6)
+        
+    if tipo == "MES":
+        start_week = today.replace(day=1)
+        next_month = start_week.replace(month=start_week.month + 1, day=1)
+        end_week = next_month - timedelta(days=1)
+
+    if tipo == "HOY":
+        start_week = today.replace(hour=0, minute=0, second=0, microsecond=0)
+
+        # Obtener el último momento del día (23:59:59)
+        end_week = today.replace(hour=23, minute=59, second=59, microsecond=999999)
+        
+    expenses = db.query(Movimiento.descripcion, Movimiento.cuenta,Movimiento.id_movimientos).\
+                filter(Movimiento.id_usuario == user_id, 
+                    Movimiento.tipo_movimiento == 'GASTO', 
+                    Movimiento.estado_gasto == True, 
+                    between(Movimiento.fecha, start_week.date(), end_week.date())).\
+                all()
+
+    total_expenses = sum(exp[1] for exp in expenses)  
+    details = [{"descripcion": exp[0], "cuenta": float(exp[1]),"id_movimientos":int(exp[2])} for exp in expenses]
+    return total_expenses,details
+
+
+def get_consulted_expenses(db: Session, user_id: str,start_week : date,end_week:date):
+    expenses = db.query(Movimiento.descripcion, Movimiento.cuenta).\
+                filter(Movimiento.id_usuario == user_id, 
+                    Movimiento.tipo_movimiento == 'GASTO', 
+                    Movimiento.estado_gasto == True, 
+                    between(Movimiento.fecha, start_week, end_week)).\
+                all()
+
+    total_expenses = sum(exp[1] for exp in expenses)  # Sumando las cuentas (índice 1)
+    
+    # Convertir los detalles de gastos a una lista de diccionarios
+    details = [{"descripcion": exp[0], "cuenta": float(exp[1])} for exp in expenses]
+    return total_expenses,details
+
+def buscar_movimientos(id:int,db:Session):
+    movimiento_db = db.query(Movimiento).filter(Movimiento.id_movimientos == id).first()
+    return movimiento_db
+
+def money_account(db:Session,id_usuario:str,fecha_inicio:date = None,fecha_fin:date = None):
+    if fecha_inicio is None or fecha_fin is None:
+        fecha_inicio = str(date.today())
+        fecha_fin = str(date.today())
+        
+    ingresos = db.query(func.sum(Movimiento.cuenta)).filter(
+        Movimiento.tipo_movimiento == 'INGRESO',
+        between(Movimiento.fecha,fecha_inicio,fecha_fin),
+        Movimiento.id_usuario == id_usuario,
+        Movimiento.estado_gasto == 1
+    ).scalar() or 0
+
+    gastos = db.query(func.sum(Movimiento.cuenta)).filter(
+        Movimiento.tipo_movimiento == 'GASTO',
+        between(Movimiento.fecha,fecha_inicio,fecha_fin),
+        Movimiento.id_usuario == id_usuario,
+        Movimiento.estado_gasto == 1
+    ).scalar() or 0
+    
+    resultado = ingresos - gastos;
+    return resultado
+
+
+def update_movimiento_crud(movi:MovimientosUpdate,db:Session):
+    movimiento_db = buscar_movimientos(movi.id_movimientos,db)
+    if movimiento_db:
+        try:
+            movimiento_db.cuenta = movi.cuenta
+            movimiento_db.tipo_movimiento = movi.tipo_movimiento
+            movimiento_db.descripcion = movi.descripcion
+            db.add(movimiento_db)
+            db.commit()
+            db.refresh(movimiento_db)
+            return movimiento_db    
+        except Exception as e :
+            db.rollback()
+            print(f"Error al actualizar movimiento: {str(e)}",file=sys.stderr)
+            raise HTTPException(status_code=500,detail=f"Error al actualizar un movimiento: {str(e)} ")
+    return None
+
+
+def update_movimientos_status_crud(movi:MovimientosUpdateStatus, db:Session):
+    movimientos_db = buscar_movimientos(movi.id_movimientos, db)
+    if movimientos_db:
+        try:
+            movimientos_db.estado_gasto = movi.estado_gasto
+            db.add(movimientos_db)
+            db.commit()
+            
+            return True
+        except Exception as e :
+            db.rollback()
+            print(f"Error al update un movimiento {str(e)}",file=sys.stderr)
+            raise HTTPException(status_code=500,detail=f"Error al update movimiento: {str(e)} ")
+        
+    return False

cruds/ReservaCrud.py

@@ -0,0 +1,153 @@
+import sys
+
+from fastapi import HTTPException
+from schemas.ReservaSh import *
+from models.ReservaM import Reserva
+from sqlalchemy.orm import Session
+from sqlalchemy import asc,between
+from datetime import date,time
+from datetime import datetime
+from core.utils import get_list_reserve,sort_object_by_index
+list_reserve = get_list_reserve()
+def create_new_reserve(reserve:ReserveCreate, id_usuario:str,created_at:datetime,db:Session):
+    isExistReserve = get_reserve_by_time_date(reserve.hora,reserve.fecha,id_usuario,db)
+    if isExistReserve != None:
+        raise HTTPException(status_code=409, detail="Conflict:The reserve already exist.")
+    db_reserve = Reserva(
+        id_usuario = id_usuario,
+        cliente = reserve.cliente,
+        fecha = reserve.fecha,
+        hora = reserve.hora,
+        created_at = created_at
+    )
+
+    try:
+        db.add(db_reserve)
+        db.commit()
+        db.refresh(db_reserve)
+        db.close()
+
+        return db_reserve
+    except Exception as e:
+        db.rollback()
+        print(f"error creating reserve: {str(e)}",file=sys.stderr)
+        raise HTTPException(status_code=500,detail=f"error creating reserve: {str(e)}")
+    
+def update_reserve(reserve:ReserveUpdate, user_id:str, db:Session):
+    reserve_db = get_reserve_by_id(reserve.id_reserva, user_id, db)
+    if reserve_db.estado_reserva == 0:
+        try:
+            reserve_db.cliente = reserve.cliente
+            reserve_db.fecha = reserve.fecha
+            reserve_db.hora = reserve.hora
+            db.add(reserve_db)
+            db.commit()
+            db.refresh(reserve_db)
+            db.close()
+
+            return reserve_db
+        except Exception as e:
+            db.rollback()
+            print(f"error updating reserve: {str(e)}",file=sys.stderr)
+            raise HTTPException(status_code=500,detail=f"error updating reserve: {str(e)} ")
+    else:
+        return None
+    
+def update_reserve_tarifa(reserve:ReserveUpdateTarifa, user_id:str, db:Session):
+    reserve_db = get_reserve_by_id(reserve.id_reserva, user_id, db)
+    if reserve_db:
+        try:
+            reserve_db.estado_reserva = 1
+            reserve_db.id_tarifa = reserve.id_tarifa
+
+            db.add(reserve_db)
+            db.commit()
+            db.refresh(reserve_db)
+            db.close()
+
+            return reserve_db
+        except Exception as e:
+            db.rollback()
+            print(f"error updating reserve: {str(e)}",file=sys.stderr)
+            raise HTTPException(status_code=500,detail=f"error updating reserve: {str(e)} ")
+    else:
+        return None
+    
+
+def get_reserve_by_id(id_reserve:int, user_id:str, db:Session):
+    reserve_db = db.query(Reserva).filter((Reserva.id_reserva == id_reserve) & (Reserva.id_usuario == user_id)  ).first()
+    return reserve_db
+
+def get_reserve_by_time_date(time:time,date:date, user_id:str, db:Session):
+    reserve_db = db.query(Reserva).filter(
+        Reserva.hora == time,
+        Reserva.fecha == date,
+        Reserva.id_usuario == user_id
+    ).first()
+    if reserve_db is None:
+        return None
+    return reserve_db
+
+def update_status_reserve(reserve:ReserveUpdateStatus,db:Session,id_user:str):
+    reserve_db = get_reserve_by_id(reserve.id_reserva,id_user,db)
+    if reserve_db:
+        try:
+            reserve_db.estado_reserva = reserve.estado_reserva
+            db.add(reserve_db)
+            db.commit()
+            return reserve_db
+
+        except Exception as e:
+            db.rollback()
+            print(f"Error al update una reserva {str(e)}",file=sys.stderr)
+            raise HTTPException(status_code=500,detail=f"Error al update una reserva: {str(e)} ")
+    raise HTTPException(status_code=500,detail="No se encontro nada")
+
+
+
+
+def get_reserve_false(id_user:str,db):
+    fecha = str(date.today())
+    reserve_db = db.query(Reserva).filter((Reserva.id_usuario == id_user ) & (Reserva.fecha == fecha) & (Reserva.estado_reserva == 0)).order_by(asc(Reserva.hora)).all()
+    return reserve_db
+
+def get_reserve_all(id_user:str,db,fecha_inicio:date = None,fecha_fin:date = None):
+    if fecha_inicio is None or fecha_fin is None:
+        fecha_inicio = str(date.today())
+        fecha_fin = str(date.today())
+        
+    reserve_db = db.query(Reserva).filter(
+        Reserva.id_usuario == id_user, 
+        between(Reserva.fecha, fecha_inicio, fecha_fin)
+    ).order_by(asc(Reserva.hora)).all()
+    
+    return reserve_db
+
+def get_reservations_by_date(id_user:str,db,fecha:date = None): 
+    if (fecha is None): fecha = str(date.today())
+    reservations_db = db.query(Reserva).filter(
+        Reserva.id_usuario == id_user,
+        Reserva.fecha == fecha
+    ).all()
+    return reservations_db
+    
+
+def get_reservations_available(id_user:str,db,fecha:date = None):
+    list_reservations = get_reservations_by_date(id_user,db,fecha)
+    object_reservations = {}
+        
+    for reserva_db in list_reservations:
+        time_reserve = reserva_db.hora.strftime('%H:%M:%S')
+        if time_reserve in list_reserve:
+            object_reservations[time_reserve] = reserva_db.cliente;
+            
+    for time_reserve in list_reserve:
+        # bueno mi so el setdefault lo que hace es que si el objeto tiene esa clave no lo modifica de lo contrario coloca el valor Disponible
+        object_reservations.setdefault(time_reserve, "Disponible")
+            
+    object_sort = sort_object_by_index(object_reservations)
+    reservations_available = list(object_sort.items())
+    return reservations_available
+        
+    
+    

cruds/TarifaCrud.py

@@ -0,0 +1,71 @@
+import sys
+from models.TarifaM import Tarifa
+from fastapi import HTTPException
+from schemas.TarifaSh import *
+from sqlalchemy.orm import Session
+from sqlalchemy import desc
+from datetime import datetime
+
+def create_new_tarifa(tarifa_create:TarifaCreate,id_usuario:str,fecha_hora:datetime,db:Session):
+    db_tarifa = Tarifa(
+        id_usuario = id_usuario,
+        descripcion = tarifa_create.descripcion,
+        costo = tarifa_create.costo,
+        created_at = fecha_hora
+    )
+
+    try:
+        db.add(db_tarifa)
+        db.commit()
+        db.refresh(db_tarifa)
+        db.close()
+        return db_tarifa
+    except Exception as e :
+        db.rollback()
+        # Imprimir el error en la consola
+        print(f"Error al crear una tarifa: {str(e)}",file=sys.stderr)
+        raise HTTPException(status_code=500,detail=f"Error al crear una tarifa: {str(e)} ")
+
+def get_all_tarifas(db:Session,id_usuario:str):
+    tarifas = db.query(Tarifa).filter(Tarifa.id_usuario == id_usuario,Tarifa.estado_tarifa == 1).order_by(desc(Tarifa.created_at)).all()
+    if tarifas is None:
+        return None
+    return tarifas
+
+def get_tarifa_by_id(id_tarifa:int,db:Session):
+    tarifa_db = db.query(Tarifa).filter(Tarifa.id_tarifa == id_tarifa).first()
+    return tarifa_db
+
+def tarifa_update(tarifaUpdate:TarifaUpdate,db:Session):
+    tarifa_db = get_tarifa_by_id(tarifaUpdate.id_tarifa,db)
+    if tarifa_db:
+        try:
+            tarifa_db.descripcion = tarifaUpdate.descripcion
+            tarifa_db.costo = tarifaUpdate.costo
+            db.add(tarifa_db)
+            db.commit()
+            db.refresh(tarifa_db)
+            return tarifa_db    
+        except Exception as e :
+            db.rollback()
+            print(f"Error al crear un usuario: {str(e)}",file=sys.stderr)
+            raise HTTPException(status_code=500,detail=f"Error al crear usuario: {str(e)} ")
+    raise HTTPException(status_code=404, detail="No existen tarifas")
+
+
+def delete_tarifa(tarifaUpdateStatus:TarifaBase,db:Session):
+    tarifa_db = get_tarifa_by_id(tarifaUpdateStatus.id_tarifa,db)
+    if tarifa_db:
+        try:
+            tarifa_db.estado_tarifa = False
+            db.add(tarifa_db)
+            db.commit()
+            db.refresh(tarifa_db)
+            return tarifa_db
+        except Exception as e:
+            db.rollback()
+            print(f"Error al Editar Estado: {str(e)}",file=sys.stderr)
+            raise HTTPException(status_code=500,detail=f"Error al Editar usuario: {str(e)} ")
+    raise HTTPException(status_code=404, detail="No existe la tarifas")
+
+

cruds/UsuarioCrud.py

@@ -0,0 +1,96 @@
+import sys # Mandar mensajes de error al log
+
+from models.UsuarioM import User
+from fastapi import HTTPException
+from schemas.UsuarioSh import UserCreate,UserRead, UserUpdate, UserUpdateStatus
+from sqlalchemy.orm import Session
+from core.seguridad import get_hashed_password,verify_password
+from core.utils import generate_user_id
+
+def create_new_user(user:UserCreate,db:Session):
+    db_user = User(
+        id_usuario = generate_user_id(),
+        correo = user.correo,
+        contrasenia = get_hashed_password(user.contrasenia),
+        rol = "BARBERO"
+    )
+
+    try:
+        db.add(db_user)
+        db.commit()
+        db.refresh(db_user)
+        db.close()
+        return db_user
+    except Exception as e :
+        db.rollback()
+        # Imprimir el error en la consola
+        print(f"Error al crear un usuario: {str(e)}",file=sys.stderr)
+        raise HTTPException(status_code=500,detail=f"Error al crear usuario: {str(e)} ")
+
+def get_user_by_email(email:str,db:Session):
+    user = db.query(User).filter(User.correo == email).first()
+    return user
+
+# def get_user_by_email_verify(user_id : str,email:str,db:Session):
+#     user_db = db.query(User).filter(User.user_id == user_id).first()
+#     if user_db.mail != email: 
+#         validation = get_user_by_email(email,db)
+#         if validation is None:
+#             return True
+#         else:
+#             return False
+#     return True
+    
+        
+
+def get_user_by_id(id:str,db:Session):
+    user = db.query(User).filter(User.id_usuario == id).first()
+    return user
+
+def get_all_users_bd(db:Session):
+    users = db.query(User).filter(User.rol == "BARBERO").all()
+    return users
+
+def authenticate_user(username:str,password:str,db:Session):
+    user = get_user_by_email(username,db)
+    if not user:
+        return False
+    if not verify_password(password,user.contrasenia):
+        return False
+    
+    return user
+
+def update_user_crud(user:UserUpdate,db:Session):
+    user_db = get_user_by_id(user.id_usuario,db)
+    if user_db:
+        try:
+            if user.contrasenia:
+                user_db.contrasenia = get_hashed_password(user.contrasenia)
+            user_db.correo = user.correo
+            db.add(user_db)
+            db.commit()
+            db.refresh(user_db)
+            return user_db    
+        except Exception as e :
+            db.rollback()
+            print(f"Error al crear un usuario: {str(e)}",file=sys.stderr)
+            raise HTTPException(status_code=500,detail=f"Error al crear usuario: {str(e)} ")
+    return None
+
+
+def update_user_status_crud(user:UserUpdateStatus, db:Session):
+    user_db = get_user_by_id(user.user_id, db)
+    if user_db:
+        try:
+            user_db.estado_usuario = user.estado_usuario
+            db.add(user_db)
+            db.commit()
+            
+            return True
+        except Exception as e :
+            db.rollback()
+            print(f"Error al crear un usuario: {str(e)}",file=sys.stderr)
+            raise HTTPException(status_code=500,detail=f"Error al crear usuario: {str(e)} ")
+        
+    return False
+

db/barber_db.sql

@@ -0,0 +1,70 @@
+DROP DATABASE IF EXISTS barberia;
+CREATE DATABASE barberia;
+USE barberia;
+
+SET SQL_MODE = "NO_AUTO_VALUE_ON_ZERO";
+START TRANSACTION;
+SET time_zone = "-05:00";
+
+
+
+CREATE TABLE usuario(
+    id_usuario CHAR(30) PRIMARY KEY,
+    correo VARCHAR(80) NOT NULL,
+    contrasenia VARCHAR(250) NOT NULL,
+    rol ENUM('SUPERADMIN','BARBERO'),
+    created_at TIMESTAMP,
+    estado_usuario TINYINT(1) DEFAULT 1
+);
+
+CREATE TABLE tarifa(
+    id_tarifa INT UNSIGNED AUTO_INCREMENT PRIMARY KEY,
+    id_usuario CHAR(30),
+    descripcion VARCHAR(100) NOT NULL,
+    costo SMALLINT UNSIGNED NOT NULL,
+    created_at TIMESTAMP,
+    estado_tarifa TINYINT(1) DEFAULT 1,
+    FOREIGN KEY (id_usuario) REFERENCES usuario(id_usuario)
+);
+
+CREATE TABLE reserva (
+    id_reserva INT UNSIGNED AUTO_INCREMENT PRIMARY KEY,
+    id_usuario CHAR(30),
+    cliente VARCHAR(100) NOT NULL,
+    fecha DATE NOT NULL,
+    hora TIME NOT NULL,
+    estado_reserva TINYINT(1) DEFAULT 0,
+    id_tarifa INT UNSIGNED,
+    created_at TIMESTAMP,
+    FOREIGN KEY (id_tarifa) REFERENCES tarifa(id_tarifa),
+    FOREIGN KEY (id_usuario) REFERENCES usuario(id_usuario)
+);
+
+CREATE TABLE movimientos(
+    id_movimientos INT UNSIGNED AUTO_INCREMENT PRIMARY KEY,
+    id_usuario CHAR(30),
+    cuenta FLOAT(10,2) NOT NULL,
+    tipo_movimiento ENUM('INGRESO','GASTO'),
+    fecha DATE NOT NULL,
+    descripcion TEXT,
+    created_at TIMESTAMP,
+    estado_gasto TINYINT(1) DEFAULT 1,
+    FOREIGN KEY (id_usuario) REFERENCES usuario(id_usuario)
+);
+
+
+INSERT INTO `usuario` (`id_usuario`, `correo`, `contrasenia`, `rol`, `estado_usuario`) VALUES
+('42wgnk2xMsBODXI9CpFDftUxDSmSMn', 'winder@gmail.com', '$2b$12$cyr2SZu703rNSF5OkxghCuzPlNZGOSDS2clPPJcCSau3RPDHtdes.', 'SUPERADMIN', 1),
+('7hDj9DmYUSdfrrbjQU5iWKClL4UYen', 'patron@mail.com', '$2b$12$SfVZEyvAGZuGdlnKYZKBdOEpbgBLAlR4d5cF6KPkONyWWLKD3pmqm', 'SUPERADMIN', 1),
+('DwoznM0AvFXV28EPDhpCl9wPOsqFux', 'user10@example.com', '$2b$12$fsdlCeTvr1Iq5jIX5m93GuKGyfWmkzo6rI7LOAAgmAbo7T4T96xNC', 'BARBERO', 1),
+('G0BgHtRKvSmzaoMvXmcNZEyluSM7y6', 'milu@mail.com', '$2b$12$zYuj8Nt4GHfsKy9F3S9N2OQ5Lq62TtaJEtRJUSyioIhjLKGAfxwsq', 'BARBERO', 1),
+('Gp1q2OZwEv3aklEto8cX9pvpEKMHFT', 'mateo@mail.com', '$2b$12$ExyQSeLcG/1ZovP7I/cIHOYbmpcK3BQWjWHSuSDbJXuTQfbJji.MW', 'SUPERADMIN', 1),
+('JG2PgMvagVKxRWEWK7lNAXle6TTACF', 'patron2@gmail.com', '$2b$12$iSJvhNYbQhdXu3pZJG5WSey1MZNxFHvnQY5Ljku3oCeBKpw3l6h02', 'SUPERADMIN', 1),
+('mvEPrFmVAHxiyC1eOqGu5zmT0mfrz6', 'braulio@gmail.com', '$2b$12$L3lSqvjUp9FBEu99pRQDgO2TtTIiq4aK92XvNKMwyLJ.oV7Dmv8Ty', 'SUPERADMIN', 1),
+('N8Hw0t9SXbRgjIppRteiGZeWxRLkru', 'user3@example.com', '$2b$12$sguVhgGXqsk..5P7lFqGyeFi9ge8MOc4T1ckx/1T0360PTYBRSDKG', 'BARBERO', 1),
+('OaYhqvnl6s0DJTANQX0jFPrQj8MbDw', 'JUANPISS@example.com', '$2b$12$dcxtPEBDWZR9IT.bVmSmDeEfS6wvx.G.M3rWvUlFzw6aVR1HY3oM6', 'BARBERO', 0),
+('plZr7wfSLDQac8bj1G5zVoEpr10tUM', 'user@example.com', '$2b$12$O3fLsh5FT2r9sFQztpG9..m1Nzu1C./wjseVL4Yi6CEWQvaViEFc.', 'BARBERO', 1),
+('Q62ehy208AhtcLeXgE0zzsQmrHvcec', 'user5@example.com', '$2b$12$ybcsZsGkHiygzAmDLWzuPOL0Rj9iopxcxJ66cFcfeLB3NSIvA8cC2', 'BARBERO', 1),
+('U3h1ZpO3onjHyfYu0OYh558eUiT5aF', 'user2@example.com', '$2b$12$Yo9ZMDnBUg0UfYaISgm6ROiYBK0mgPFJhoo0vWyCYnWijgV5P8SKW', 'BARBERO', 1),
+('YzR0ReQOG8bvUuv31J4yGBW8aAuVCS', 'user4@example.com', '$2b$12$SeT65vSaR5WkxJqkhmLEuez555LEaVtRzzt2aqy1tAgr1iCGH50Z2', 'BARBERO', 1);
+

db/boovngmcolkrlajvvjia.sql

@@ -0,0 +1,117 @@
+
+
+DROP DATABASE IF EXISTS barberia;
+CREATE DATABASE barberia;
+USE barberia;
+
+SET SQL_MODE = "NO_AUTO_VALUE_ON_ZERO";
+START TRANSACTION;
+SET time_zone = "-05:00";
+
+
+
+CREATE TABLE `movimientos` (
+  `id_movimientos` int UNSIGNED NOT NULL,
+  `cuenta` float(10,2) NOT NULL,
+  `tipo_movimiento` enum('INGRESO','GASTO') DEFAULT NULL,
+  `fecha` date NOT NULL,
+  `descripcion` text,
+  created_at TIMESTAMP ,
+  `estado_gasto` tinyint(1) DEFAULT '1'
+) ENGINE=InnoDB DEFAULT CHARSET=utf8;
+
+
+
+INSERT INTO `movimientos` (`id_movimientos`, `cuenta`, `tipo_movimiento`, `fecha`, `descripcion`, `estado_gasto`) VALUES
+(1, 1000.00, 'INGRESO', '2024-02-26', 'hola mundo', 1),
+(2, 1000.00, 'INGRESO', '2024-02-26', 'hola mundo', 1),
+(3, 1000.00, 'INGRESO', '2024-02-26', 'hola mundo', 1),
+(4, 1000.00, 'INGRESO', '2024-02-26', 'hola mundo', 1),
+(5, 100.00, 'GASTO', '2024-02-26', 'hola mundo ', 1),
+(6, 0.00, 'INGRESO', '2024-02-26', 'probando2', 0);
+
+CREATE TABLE `reserva` (
+  `id_reserva` int UNSIGNED NOT NULL,
+  `cliente` varchar(100) NOT NULL,
+  `fecha` date NOT NULL,
+  `hora` time NOT NULL,
+  `estado_reserva` tinyint(1) DEFAULT '0',
+  created_at TIMESTAMP ,
+  `id_tarifa` int UNSIGNED DEFAULT NULL
+) ENGINE=InnoDB DEFAULT CHARSET=utf8;
+
+
+INSERT INTO `reserva` (`id_reserva`, `cliente`, `fecha`, `hora`, `estado_reserva`, `id_tarifa`) VALUES
+(1, 'jaimito', '2024-02-26', '10:13:29', 0, NULL);
+
+
+CREATE TABLE `tarifa` (
+  `id_tarifa` int UNSIGNED NOT NULL,
+  `descripcion` varchar(100) NOT NULL,
+  `costo` smallint UNSIGNED NOT NULL,
+  created_at TIMESTAMP ,
+  `estado_tarifa` tinyint(1) DEFAULT '1'
+) ENGINE=InnoDB DEFAULT CHARSET=utf8;
+
+
+CREATE TABLE `usuario` (
+  `id_usuario` char(30) NOT NULL,
+  `correo` varchar(80) NOT NULL,
+  `contrasenia` varchar(250) NOT NULL,
+  `rol` enum('SUPERADMIN','BARBERO') DEFAULT NULL,
+  created_at TIMESTAMP ,
+  `estado_usuario` tinyint(1) DEFAULT '1'
+) ENGINE=InnoDB DEFAULT CHARSET=utf8;
+
+
+
+INSERT INTO `usuario` (`id_usuario`, `correo`, `contrasenia`, `rol`, `estado_usuario`) VALUES
+('42wgnk2xMsBODXI9CpFDftUxDSmSMn', 'winder@gmail.com', '$2b$12$cyr2SZu703rNSF5OkxghCuzPlNZGOSDS2clPPJcCSau3RPDHtdes.', 'SUPERADMIN', 1),
+('7hDj9DmYUSdfrrbjQU5iWKClL4UYen', 'patron@mail.com', '$2b$12$SfVZEyvAGZuGdlnKYZKBdOEpbgBLAlR4d5cF6KPkONyWWLKD3pmqm', 'SUPERADMIN', 1),
+('DwoznM0AvFXV28EPDhpCl9wPOsqFux', 'user10@example.com', '$2b$12$fsdlCeTvr1Iq5jIX5m93GuKGyfWmkzo6rI7LOAAgmAbo7T4T96xNC', 'BARBERO', 1),
+('G0BgHtRKvSmzaoMvXmcNZEyluSM7y6', 'milu@mail.com', '$2b$12$zYuj8Nt4GHfsKy9F3S9N2OQ5Lq62TtaJEtRJUSyioIhjLKGAfxwsq', 'BARBERO', 1),
+('Gp1q2OZwEv3aklEto8cX9pvpEKMHFT', 'mateo@mail.com', '$2b$12$ExyQSeLcG/1ZovP7I/cIHOYbmpcK3BQWjWHSuSDbJXuTQfbJji.MW', 'SUPERADMIN', 1),
+('JG2PgMvagVKxRWEWK7lNAXle6TTACF', 'patron2@gmail.com', '$2b$12$iSJvhNYbQhdXu3pZJG5WSey1MZNxFHvnQY5Ljku3oCeBKpw3l6h02', 'SUPERADMIN', 1),
+('mvEPrFmVAHxiyC1eOqGu5zmT0mfrz6', 'braulio@gmail.com', '$2b$12$L3lSqvjUp9FBEu99pRQDgO2TtTIiq4aK92XvNKMwyLJ.oV7Dmv8Ty', 'SUPERADMIN', 1),
+('N8Hw0t9SXbRgjIppRteiGZeWxRLkru', 'user3@example.com', '$2b$12$sguVhgGXqsk..5P7lFqGyeFi9ge8MOc4T1ckx/1T0360PTYBRSDKG', 'BARBERO', 1),
+('OaYhqvnl6s0DJTANQX0jFPrQj8MbDw', 'JUANPISS@example.com', '$2b$12$dcxtPEBDWZR9IT.bVmSmDeEfS6wvx.G.M3rWvUlFzw6aVR1HY3oM6', 'BARBERO', 0),
+('plZr7wfSLDQac8bj1G5zVoEpr10tUM', 'user@example.com', '$2b$12$O3fLsh5FT2r9sFQztpG9..m1Nzu1C./wjseVL4Yi6CEWQvaViEFc.', 'BARBERO', 1),
+('Q62ehy208AhtcLeXgE0zzsQmrHvcec', 'user5@example.com', '$2b$12$ybcsZsGkHiygzAmDLWzuPOL0Rj9iopxcxJ66cFcfeLB3NSIvA8cC2', 'BARBERO', 1),
+('U3h1ZpO3onjHyfYu0OYh558eUiT5aF', 'user2@example.com', '$2b$12$Yo9ZMDnBUg0UfYaISgm6ROiYBK0mgPFJhoo0vWyCYnWijgV5P8SKW', 'BARBERO', 1),
+('YzR0ReQOG8bvUuv31J4yGBW8aAuVCS', 'user4@example.com', '$2b$12$SeT65vSaR5WkxJqkhmLEuez555LEaVtRzzt2aqy1tAgr1iCGH50Z2', 'BARBERO', 1);
+
+
+
+ALTER TABLE `movimientos`
+  ADD PRIMARY KEY (`id_movimientos`);
+
+
+ALTER TABLE `reserva`
+  ADD PRIMARY KEY (`id_reserva`),
+  ADD KEY `id_tarifa` (`id_tarifa`);
+
+
+ALTER TABLE `tarifa`
+  ADD PRIMARY KEY (`id_tarifa`);
+
+
+ALTER TABLE `usuario`
+  ADD PRIMARY KEY (`id_usuario`);
+
+
+ALTER TABLE `movimientos`
+  MODIFY `id_movimientos` int UNSIGNED NOT NULL AUTO_INCREMENT, AUTO_INCREMENT=7;
+
+
+ALTER TABLE `reserva`
+  MODIFY `id_reserva` int UNSIGNED NOT NULL AUTO_INCREMENT, AUTO_INCREMENT=2;
+
+
+ALTER TABLE `tarifa`
+  MODIFY `id_tarifa` int UNSIGNED NOT NULL AUTO_INCREMENT, AUTO_INCREMENT=7;
+
+
+ALTER TABLE `reserva`
+  ADD CONSTRAINT `reserva_ibfk_1` FOREIGN KEY (`id_tarifa`) REFERENCES `tarifa` (`id_tarifa`);
+COMMIT;
+

db/session.py

@@ -0,0 +1,23 @@
+from sqlalchemy import create_engine
+from sqlalchemy.orm import sessionmaker
+from sqlalchemy.ext.declarative import declarative_base
+from core.config import settings
+
+DB_URL = settings.DATABASE_URL
+
+# Crear una instancia de motor SQLAlchemy
+engine = create_engine(DB_URL,pool_pre_ping=True)
+
+# Crear una instancia de sessionmaker
+SessionLocal = sessionmaker(autocommit=False,autoflush=False,bind=engine)
+
+# Crear una clase base para las clases de modelo
+Base = declarative_base()
+
+# Funcino para crear la sesion de base de datos
+def get_session():
+    database = SessionLocal()
+    try:
+        yield database
+    finally:
+        database.close() 

main.py

@@ -0,0 +1,22 @@
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi import FastAPI,APIRouter
+from routes import UsuarioR,MovimientosR,TarifaR, ReservaR
+from core.config import settings
+
+api_router = APIRouter()
+api_router.include_router(UsuarioR.router,prefix="/users",tags=["users"])
+api_router.include_router(MovimientosR.router,prefix="/movimientos",tags=["movimientos"])
+api_router.include_router(TarifaR.router,prefix="/tarifas",tags=["tarifas"])
+api_router.include_router(ReservaR.router,prefix="/reserves",tags=["reservas"])
+
+app = FastAPI(title=settings.PROJECT_NAME,version=settings.PROJECT_VERSION,description=settings.PROJECT_DESCRIPTION)
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+app.include_router(api_router)
+

models/Base_class.py

@@ -0,0 +1,17 @@
+from typing import AnyStr
+
+from sqlalchemy.ext.declarative import as_declarative
+from sqlalchemy.ext.declarative import declared_attr
+
+@as_declarative()
+class Base:
+    id:AnyStr
+    __name__:str
+
+    # to generate tablename from classname
+    # 
+    @declared_attr
+    def __tablename__(cls) -> str:
+        return cls.__name__.lower()
+    
+    

models/MovimientosM.py

@@ -0,0 +1,16 @@
+from sqlalchemy import Column, Integer, String, Enum, Float, Date, Boolean, func,ForeignKey
+from sqlalchemy.orm import relationship
+from models.Base_class import Base
+from models.UsuarioM import User
+class Movimiento(Base):
+    __tablename__ = 'movimientos'
+
+    id_movimientos = Column(Integer, autoincrement=True, primary_key=True)
+    id_usuario = Column(String(30),ForeignKey("usuario.id_usuario"))
+    cuenta = Column(Float(10,2), nullable=False)
+    tipo_movimiento = Column(Enum('INGRESO', 'GASTO', name='tipo_movimiento'), nullable=False)
+    fecha = Column(Date, nullable=False)  # Usa func.current_date() para obtener la fecha actual
+    descripcion = Column(String, nullable=True)
+    estado_gasto = Column(Boolean, default=True)
+    
+    usuario = relationship("User", back_populates="movimiento")

models/ReservaM.py

@@ -0,0 +1,19 @@
+from sqlalchemy.orm import relationship
+from sqlalchemy import Column, Integer, String, Float, Date, Boolean, func,Time,ForeignKey,TIMESTAMP
+from models.Base_class import Base
+from models.UsuarioM import User
+
+
+class Reserva(Base):
+    tablename = 'reserva'
+    id_reserva = Column(Integer, primary_key=True, autoincrement=True)
+    id_usuario = Column(String(30), ForeignKey('usuario.id_usuario'))
+    cliente = Column(String(100), nullable=False)
+    fecha = Column(Date, nullable=False)
+    hora = Column(Time, nullable=False)
+    estado_reserva = Column(Integer,default=0)
+    id_tarifa = Column(Integer, ForeignKey('tarifa.id_tarifa'))
+    created_at = Column(TIMESTAMP)
+    
+    tarifa = relationship("Tarifa",back_populates="reserva")
+    usuario = relationship("User", back_populates="reserva")

models/TarifaM.py

@@ -0,0 +1,20 @@
+from sqlalchemy import Column, Integer, String, Enum, Float, Date, Boolean, func,TIMESTAMP,String,ForeignKey
+from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy.orm import relationship
+from models.Base_class import Base
+from models.ReservaM import Reserva
+from models.UsuarioM import User
+from datetime import datetime
+
+class Tarifa(Base):
+    __tablename__ = 'tarifa'
+
+    id_tarifa = Column(Integer, autoincrement=True, primary_key=True)
+    id_usuario = Column(String(30),ForeignKey("usuario.id_usuario"))
+    descripcion = Column(String, nullable=True)
+    costo = Column(Integer, nullable=False)
+    estado_tarifa = Column(Boolean, default=True)
+    created_at = Column(TIMESTAMP)
+    usuario = relationship("User",back_populates="tarifa")
+    reserva = relationship("Reserva",back_populates="tarifa")
+    

models/UsuarioM.py

@@ -0,0 +1,18 @@
+from sqlalchemy import Column, Integer, String, Enum, ForeignKey, Float, Date, Boolean, Time, SmallInteger
+from enum import Enum as PyEnum
+from sqlalchemy.orm import relationship
+from models.Base_class import Base
+from sqlalchemy.orm import relationship
+
+class User(Base):
+    __tablename__ = 'usuario'
+    id_usuario = Column(String(30), primary_key=True)
+    correo = Column(String(80), nullable=False)
+    contrasenia = Column(String(250), nullable=False)
+    rol = Column(Enum('SUPERADMIN', 'BARBERO', name='rol'), nullable=False)
+    estado_usuario = Column(Boolean, default=True)
+
+    tarifa = relationship("Tarifa", back_populates="usuario")
+    reserva = relationship("Reserva",back_populates="usuario")
+    movimiento = relationship("Movimiento",back_populates="usuario")
+    

requirements.txt

@@ -0,0 +1,33 @@
+annotated-types==0.6.0
+anyio==4.2.0
+bcrypt==4.1.2
+cffi==1.16.0
+click==8.1.7
+colorama==0.4.6
+cryptography==42.0.2
+dnspython==2.5.0
+ecdsa==0.18.0
+email-validator==2.1.0.post1
+fastapi==0.109.0
+greenlet==3.0.3
+h11==0.14.0
+idna==3.6
+passlib==1.7.4
+pyasn1==0.5.1
+pycparser==2.21
+pydantic==2.5.3
+pydantic_core==2.14.6
+PyMySQL==1.1.0
+python-dotenv==1.0.1
+python-jose==3.3.0
+python-multipart==0.0.6
+pytz==2024.1
+rsa==4.9
+setuptools==68.2.2
+six==1.16.0
+sniffio==1.3.0
+SQLAlchemy==2.0.25
+starlette==0.35.1
+typing_extensions==4.9.0
+uvicorn==0.27.0
+wheel==0.41.2

routes/MovimientosR.py

@@ -0,0 +1,108 @@
+from typing import List, Optional
+from fastapi import APIRouter,Depends,HTTPException
+from fastapi.security import OAuth2PasswordBearer
+from sqlalchemy.orm import Session
+from db.session import get_session
+from schemas.MovimientosSh import *
+from schemas.UsuarioSh import UserRead
+from cruds.MovimientosCrud import *
+from routes.UsuarioR import get_current_user
+router = APIRouter()
+
+oauth2_scheme = OAuth2PasswordBearer(tokenUrl="/users/login")
+
+BARBERO = "BARBERO"
+
+@router.post("/create/",response_model=MovimientosRead)
+async def create_movimiento(movi:MovimientosCreate,db:Session = Depends(get_session), current_user: UserRead = Depends(get_current_user)):
+    if current_user.estado_usuario:
+        if current_user.rol == BARBERO:
+            return create_new_movimiento(movi,current_user.id_usuario,db)
+        else:
+            raise HTTPException(status_code=401, detail="Not authorized")
+    else:
+        raise HTTPException(status_code=403, detail="El estado del usuario es inactivo /create")
+    
+
+@router.get("/get/{movimiento_id}",response_model=MovimientosRead)
+def read_movimiento(id_movimientos:int, db:Session = Depends(get_session), current_user: UserRead = Depends(get_current_user)):
+    
+    if current_user.estado_usuario:
+        user = buscar_movimientos(id_movimientos,db)
+        if user is None:
+            raise HTTPException(status_code=404,detail="Movimiento no encontrado")
+        
+        return user
+    raise HTTPException(status_code=403, detail="El estado del usuario es inactivo")
+
+@router.post("/weekly-expenses")
+def weekly_expenses(datos: dict, db: Session = Depends(get_session), current_user: UserRead = Depends(get_current_user)):
+    if not current_user.estado_usuario:
+        raise HTTPException(status_code=403, detail="El estado del usuario es inactivo")
+    
+    if current_user.rol != 'BARBERO':
+        raise HTTPException(status_code=401, detail="Not authorized")
+    
+    tipo = datos.get("tipo")
+    if not tipo:
+        raise HTTPException(status_code=400, detail="El campo 'tipo' es requerido")
+
+    total_expenses, details = get_weekly_expenses(db, current_user.id_usuario, tipo)
+    return {"total_expenses": total_expenses, "details": details}
+
+
+
+@router.post("/consulted_expenses")
+def consulted_expenses(datos: dict, db: Session = Depends(get_session), current_user: UserRead = Depends(get_current_user)):
+    if not current_user.estado_usuario:
+        raise HTTPException(status_code=403, detail="El estado del usuario es inactivo")
+    
+    if current_user.rol != 'BARBERO':
+        raise HTTPException(status_code=401, detail="Not authorized")
+    
+    start_week = datos.get("start_week")
+    end_week = datos.get("end_week")
+    
+    if not start_week and end_week:
+        raise HTTPException(status_code=400, detail="Los campos son requeridos")
+
+    total_expenses, details = get_consulted_expenses(db, current_user.id_usuario, start_week,end_week)
+    return {"total_expenses": total_expenses, "details": details}
+
+    
+@router.get("/get-cuenta")
+async def account_money(fecha_inicio : Optional[str] = None,fecha_fin : Optional[str] = None,db:Session = Depends(get_session),current_user:UserRead = Depends(get_current_user)):
+    if current_user.estado_usuario:
+        if current_user.rol == BARBERO:
+            cuenta = money_account(db,current_user.id_usuario,fecha_inicio,fecha_fin)
+            return {"money_account":cuenta}
+        raise HTTPException(status_code=401, detail="Not authorized")
+    raise HTTPException(status_code=403, detail="El estado del usuario es inactivo /get_reserve_pendiente")
+     
+@router.post("/update-movimiento", response_model=MovimientosRead)
+def update_user_func(movi: MovimientosUpdate, db: Session = Depends(get_session), current_user: UserRead = Depends(get_current_user)):
+    
+    if current_user.estado_usuario:
+        if current_user.rol == BARBERO:
+           movimientoread = update_movimiento_crud(movi,db)
+           if movimientoread  is None:
+               raise HTTPException(status_code=401, detail="no se encontro el movimiento")
+           return movimientoread
+                
+        raise HTTPException(status_code=401, detail="Not authorized")
+    else:
+        raise HTTPException(status_code=403, detail="El estado del usuario es inactivo")
+    
+
+@router.post("/update-movimientos-status")
+def update_movimientos_status(movi: MovimientosUpdateStatus, db: Session = Depends(get_session), current_user: UserRead = Depends(get_current_user)):
+    
+    if current_user.estado_usuario:
+        if current_user.rol == BARBERO:
+            statusUpdate = update_movimientos_status_crud(movi, db)
+            if statusUpdate:
+                return {"message:":"The movimiento status has been successfully updated", "status": statusUpdate}
+            return {"message:":"An error occurred at the time of updating the movimiento.", "status": statusUpdate}    
+        raise HTTPException(status_code=401, detail="Not authorized") 
+    else:
+        raise HTTPException(status_code=403, detail="El estado del usuario es inactivo")

routes/ReservaR.py

@@ -0,0 +1,95 @@
+from typing import List,Optional
+from fastapi import APIRouter, Depends, HTTPException
+from fastapi.security import OAuth2PasswordBearer
+from sqlalchemy.orm import Session
+from core.seguridad import verify_token
+from cruds.ReservaCrud import *
+from cruds.UsuarioCrud import get_user_by_id
+import pytz
+from db.session import get_session
+from schemas.ReservaSh import *
+from schemas.UsuarioSh import UserRead
+
+# Obtener la zona horaria de Colombia
+colombia_tz = pytz.timezone('America/Bogota')
+
+router = APIRouter()
+
+oauth2_scheme = OAuth2PasswordBearer(tokenUrl="/users/login")
+
+BARBERO = "BARBERO"
+
+async def get_current_user(token:str = Depends(oauth2_scheme), db:Session = Depends(get_session)):
+    user_id = await verify_token(token)
+    if user_id is None:
+        raise HTTPException(status_code=481,detail="Invalid token")
+    user_db = get_user_by_id(user_id, db)
+    if user_db is None:
+        raise HTTPException(status_code=484,detail="User not found")
+    return user_db
+
+@router.post("/create-reserve",response_model=ReserveRead)
+async def create_reserve(reserve:ReserveCreate,db:Session = Depends(get_session),current_user:UserRead = Depends(get_current_user)):
+    if current_user.estado_usuario:
+        if current_user.rol == BARBERO:
+            fecha_actual_colombia = datetime.now(colombia_tz)
+            return create_new_reserve(reserve,current_user.id_usuario,fecha_actual_colombia,db)
+        else:
+            raise HTTPException(status_code=401, detail="Not authorized")
+    else:
+        raise HTTPException(status_code=403, detail="El estado del usuario es inactivo /create-reserve")
+    
+@router.post("/update-reserve", response_model=ReserveRead)
+def reserve_update(reserve: ReserveUpdate, db: Session = Depends(get_session), current_user: UserRead = Depends(get_current_user)):
+    if current_user.estado_usuario and current_user.rol == BARBERO:
+        updated_reserve = update_reserve(reserve, current_user.id_usuario, db)
+        if updated_reserve is None:
+            raise HTTPException(status_code=404, detail="reserve not found or reserva is not at 0")
+        return updated_reserve
+    else:
+        raise HTTPException(status_code=401, detail="Not authorized")
+    
+@router.post("/update-reserve-tarifa", response_model=ReserveRead)
+def reserve_update_tarifa(reserve: ReserveUpdateTarifa, db: Session = Depends(get_session), current_user: UserRead = Depends(get_current_user)):
+    if current_user.estado_usuario and current_user.rol == BARBERO:
+        updated_reserve_tarifa = update_reserve_tarifa(reserve, current_user.id_usuario, db)
+        if updated_reserve_tarifa is None:
+            raise HTTPException(status_code=404, detail="reserve tarifa not found")
+        return updated_reserve_tarifa
+    else:
+        raise HTTPException(status_code=401, detail="Not authorized")
+    
+@router.post("/delete-reserve",response_model=ReserveRead)
+async def update_status(reserve:ReserveUpdateStatus,db:Session = Depends(get_session),current_user:UserRead = Depends(get_current_user)):
+    if current_user.estado_usuario:
+        if current_user.rol == BARBERO:
+            return update_status_reserve(reserve,db,current_user.id_usuario)
+        raise HTTPException(status_code=401, detail="Not authorized")
+    raise HTTPException(status_code=403, detail="El estado del usuario es inactivo /update-reserve")
+
+
+
+@router.get("/get-reserve-pendiente",response_model=List[ReserveRead])
+async def get_reserve_pendiente(db:Session = Depends(get_session),current_user:UserRead = Depends(get_current_user)):
+    if current_user.estado_usuario:
+        if current_user.rol == BARBERO:
+            return get_reserve_false(current_user.id_usuario,db)
+        raise HTTPException(status_code=401, detail="Not authorized")
+    raise HTTPException(status_code=403, detail="El estado del usuario es inactivo /get_reserve_pendiente")
+
+
+@router.get("/get-reserve-all",response_model=List[ReserveRead])
+async def get_all(fecha_inicio : Optional[str] = None,fecha_fin : Optional[str] = None,db:Session = Depends(get_session),current_user:UserRead = Depends(get_current_user)):
+    if current_user.estado_usuario:
+        if current_user.rol == BARBERO:
+            return get_reserve_all(current_user.id_usuario,db,fecha_inicio,fecha_fin)
+        raise HTTPException(status_code=401, detail="Not authorized")
+    raise HTTPException(status_code=403, detail="El estado del usuario es inactivo /get_reserve_all")
+
+@router.get("/get-reservations-available")
+async def reservations_available(fecha:Optional[str] = None,db:Session = Depends(get_session),current_user:UserRead = Depends(get_current_user)):
+    if current_user.estado_usuario:
+        if current_user.rol == BARBERO:
+            return get_reservations_available(current_user.id_usuario,db,fecha)
+        raise HTTPException(status_code=401, detail="Not authorized")
+    raise HTTPException(status_code=403, detail="El estado del usuario es inactivo /get-reservations-available")

routes/TarifaR.py

@@ -0,0 +1,74 @@
+from typing import List
+from fastapi import APIRouter,Depends,HTTPException
+from fastapi.security import OAuth2PasswordBearer
+from sqlalchemy.orm import Session
+from db.session import get_session
+from schemas.TarifaSh import *
+from cruds.TarifaCrud import *
+from schemas.UsuarioSh import UserRead
+from routes.UsuarioR import get_current_user
+import pytz
+
+router = APIRouter()
+oauth2_scheme = OAuth2PasswordBearer(tokenUrl="/users/login")
+BARBERO = "BARBERO"
+
+
+# Obtener la zona horaria de Colombia
+colombia_tz = pytz.timezone('America/Bogota')
+
+# # Obtener la fecha actual en la zona horaria de Colombia
+
+@router.post("/create-tarifa/",response_model=TarifaRead)
+def create_tarifa(tarifa_create:TarifaCreate,db:Session = Depends(get_session),current_user: UserRead = Depends(get_current_user)):
+    if current_user.estado_usuario:
+        if current_user.rol == BARBERO:
+            fecha_actual_colombia = datetime.now(colombia_tz)
+            return create_new_tarifa(tarifa_create,current_user.id_usuario,fecha_actual_colombia,db)
+        else:
+            raise HTTPException(status_code=401, detail="No esta autorizado")
+    else:
+        raise HTTPException(status_code=401, detail="Su usuario esta inactivo")
+
+@router.get("/get-tarifas/",response_model=List[TarifaRead])
+def obtener_tarifas(db:Session = Depends(get_session),current_user: UserRead = Depends(get_current_user)):
+    if current_user.estado_usuario:
+        if current_user.rol == BARBERO:
+            tarifas = get_all_tarifas(db,current_user.id_usuario)
+            if tarifas is None:
+                raise HTTPException(status_code=404, detail="No existen tarifas")
+            else:
+                return tarifas
+        else:
+            raise HTTPException(status_code=401, detail="No esta autorizado")
+    else:
+        raise HTTPException(status_code=401, detail="Su usuario esta inactivo")
+
+@router.post("/update-tarifa/",response_model=TarifaUpdate)
+def update_tarifa(updateTarifa:TarifaUpdate,db:Session = Depends(get_session),current_user: UserRead = Depends(get_current_user)):
+    if current_user.estado_usuario:
+        if current_user.rol == BARBERO:
+            tarifas = tarifa_update(updateTarifa,db)
+            if tarifas is None:
+                raise HTTPException(status_code=404, detail="No existen tarifas")
+            else:
+                return tarifas
+        else:
+            raise HTTPException(status_code=401, detail="No esta autorizado")
+    else:
+        raise HTTPException(status_code=401, detail="Su usuario esta inactivo")
+
+
+@router.post("/update-tarifa-status/",response_model=TarifaUpdate)
+def update_tarifa_status(updateTarifaStatus:TarifaBase,db:Session = Depends(get_session),current_user: UserRead = Depends(get_current_user)):
+    if current_user.estado_usuario:
+        if current_user.rol == BARBERO:
+            tarifas = delete_tarifa(updateTarifaStatus,db)
+            if tarifas is None:
+                raise HTTPException(status_code=404, detail="No existen la Tarifa")
+            else:
+                return tarifas
+        else:
+            raise HTTPException(status_code=401, detail="No esta autorizado")
+    else:
+        raise HTTPException(status_code=401, detail="Su usuario esta inactivo")

routes/UsuarioR.py

@@ -0,0 +1,160 @@
+from typing import List
+from fastapi import APIRouter,Depends,HTTPException
+from fastapi.security import OAuth2PasswordBearer, OAuth2PasswordRequestForm
+from sqlalchemy.orm import Session
+from db.session import get_session
+from schemas.UsuarioSh import *
+from cruds.UsuarioCrud import create_new_user,get_user_by_email,get_user_by_id, authenticate_user, update_user_crud, update_user_status_crud, get_all_users_bd
+from core.seguridad import verify_token, verify_password, create_access_token, get_hashed_password
+
+router = APIRouter()
+
+tokens = []
+
+oauth2_scheme = OAuth2PasswordBearer(tokenUrl="/users/login")
+
+SUPERADMIN = "SUPERADMIN"
+
+async def get_current_user(token: str = Depends(oauth2_scheme), db: Session = Depends(get_session)):
+    user_id = await verify_token(token)
+    if user_id is None:
+        if token in tokens:
+            tokens.remove(token)
+            raise HTTPException(status_code=484, detail="Token delete for time ")
+        else:
+            raise HTTPException(status_code=400, detail="El token proporcionado no es válido")
+    user_db = get_user_by_id(user_id, db)
+    if user_db is None:
+        raise HTTPException(status_code=484, detail="User not found")
+    return user_db
+
+@router.post("/create/",response_model=UserRead)
+async def create_user(user:UserCreate,db:Session = Depends(get_session), current_user: UserRead = Depends(get_current_user)):
+    
+    if current_user.estado_usuario:
+        
+        if current_user.rol == SUPERADMIN:
+        
+            verify_user = get_user_by_email(user.correo,db)
+            if verify_user is None:
+                return create_new_user(user,db)
+            
+            raise HTTPException(status_code=404,detail="Email already exists")
+        else:
+            raise HTTPException(status_code=401, detail="Not authorized")
+    else:
+        raise HTTPException(status_code=403, detail="El estado del usuario es inactivo /create")
+    
+
+@router.get("/get/{user_id}",response_model=UserRead)
+def read_user(user_id:str, db:Session = Depends(get_session), current_user: UserRead = Depends(get_current_user)):
+    
+    if current_user.estado_usuario:
+        if current_user.rol == SUPERADMIN:
+            user = get_user_by_id(user_id,db)
+            if user is None:
+                raise HTTPException(status_code=404,detail="usuario no encontrado")
+            
+            return user
+        raise HTTPException(status_code=401, detail="Not authorized")
+    raise HTTPException(status_code=403, detail="El estado del usuario es inactivo")
+
+@router.get("/get-all-users", response_model= List[UserRead])
+def read_all_users_func(db:Session = Depends(get_session), current_user: UserRead = Depends(get_current_user)):
+
+    if current_user.estado_usuario:
+        if current_user.rol == SUPERADMIN:
+            usersFind = get_all_users_bd(db)
+            if usersFind is None:
+                raise HTTPException(status_code=404,detail="No hay usuarios registrados por el momento")
+            return usersFind
+        raise HTTPException(status_code=401, detail="Not authorized")
+    raise HTTPException(status_code=403, detail="El estado del usuario es inactivo")
+
+
+
+    
+
+@router.post("/login",response_model=Token)
+async def login_for_acces(form_data: OAuth2PasswordRequestForm= Depends(), db: Session = Depends(get_session)):
+    curr_user = authenticate_user(form_data.username, form_data.password, db)
+    if not curr_user:
+        raise HTTPException(
+            status_code=401,
+            detail="Invalid username or password",
+            headers={"WWW-Authenticate": "Bearer"}
+        )
+    if curr_user.estado_usuario:
+        access_token = create_access_token(data={"sub": curr_user.id_usuario})
+        tokens.append(access_token)
+        return {"access_token": access_token, "correo":curr_user.correo,"token_type":"bearer","rol":curr_user.rol}
+    else:
+        raise HTTPException(status_code=403, detail="El estado del usuario es inactivo")
+     
+     
+@router.post("/update-user", response_model=UserRead)
+def update_user_func(user: UserUpdate, db: Session = Depends(get_session), current_user: UserCurrent = Depends(get_current_user)):
+        
+    if current_user.estado_usuario:
+        if current_user.id_usuario == user.id_usuario:
+            user_verify = get_user_by_email(user.correo, db)
+            if user_verify is None or user_verify.id_usuario == user.id_usuario:
+                if user.contrasenia and user.contraActual:  #Verificar si la contrasenia actual y la nueva son diferentes de null (None)
+                    passwordVer = verify_password(user.contraActual, current_user.contrasenia)
+                    if passwordVer: 
+                        user_return = update_user_crud(user, db)
+                        if user_return is None:
+                            raise HTTPException(status_code=403, detail="No se encontró el usuario por el id")
+                        return user_return
+                    raise HTTPException(status_code=404, detail="La contraseña actual es incorrecta")
+                else:
+                    user_return = update_user_crud(user, db)
+                    if user_return is None:
+                        raise HTTPException(status_code=403, detail="No se encontró el usuario por el id")
+                    return user_return
+            raise HTTPException(status_code=404, detail="El email ya existe")
+        raise HTTPException(status_code=401, detail="Not authorized")
+    else:
+        raise HTTPException(status_code=403, detail="El estado del usuario es inactivo")
+
+@router.post("/update-user-status")
+def update_user_status_func(user: UserUpdateStatus, db: Session = Depends(get_session), current_user: UserRead = Depends(get_current_user)):
+    
+    if current_user.estado_usuario:
+        if current_user.rol == SUPERADMIN:
+            statusUpdate = update_user_status_crud(user, db)
+            if statusUpdate:
+                return {"message:":"The user's status has been successfully updated", "status": statusUpdate}
+            return {"message:":"An error occurred at the time of updating the user.", "status": statusUpdate}    
+        raise HTTPException(status_code=401, detail="Not authorized") 
+    else:
+        raise HTTPException(status_code=403, detail="El estado del usuario es inactivo")
+
+
+
+@router.post("/logout")
+def logout_user(token: str, current_user: UserRead = Depends(get_current_user)):
+    print(token)
+    if current_user.estado_usuario:
+        if token in tokens:
+            tokens.remove(token)
+            return {"msg": "Sesión cerrada exitosamente","status":True}
+        else:
+            raise HTTPException(status_code=400, detail="El token proporcionado no es válido")
+    else:
+        raise HTTPException(status_code=403, detail="El estado del usuario es inactivo")
+
+
+@router.post("/get-user-token", response_model=UserRead)
+async def get_user_log(token:str, db:Session = Depends(get_session), current_user: UserRead = Depends(get_current_user)):
+    if current_user.estado_usuario:
+        user_id = await verify_token(token)
+        if user_id:
+            user = get_user_by_id(user_id, db)
+            if user is None:
+                raise HTTPException(status_code=400, detail="El usuario no existe")
+            return user
+        raise HTTPException(status_code=400, detail="El usuario no se encontró con el token")
+    raise HTTPException(status_code=400, detail="El usuario esta desactivado")
+            
+            

schemas/MovimientosSh.py

@@ -0,0 +1,34 @@
+from pydantic import BaseModel
+from typing import List
+from enum import Enum as PydanticEnum
+from datetime import date
+
+class MovimientosStatus(str,PydanticEnum):
+    INGRESO = 'INGRESO'
+    GASTO = 'GASTO'
+
+class MovimientosBase(BaseModel):
+    tipo_movimiento:MovimientosStatus
+    descripcion : str
+
+class MovimientosCreate(MovimientosBase):
+    cuenta : int
+    fecha : date
+
+class MovimientosRead(MovimientosBase):
+    fecha : date
+    cuenta : int
+    id_movimientos: int
+    estado_gasto : bool
+
+    
+class MovimientosUpdate(MovimientosBase):
+    id_movimientos: int
+    cuenta : int
+    
+    
+class MovimientosUpdateStatus(BaseModel):
+    id_movimientos: int
+    estado_gasto : bool
+
+

schemas/ReservaSh.py

@@ -0,0 +1,26 @@
+from pydantic import BaseModel
+from datetime import date, time
+
+class ReserveCreate(BaseModel):
+    cliente:str
+    fecha:date
+    hora:time
+
+class ReserveRead(ReserveCreate):
+    id_reserva:int
+    estado_reserva:int
+
+
+class ReserveUpdateStatus(BaseModel):
+    id_reserva: int
+    estado_reserva : int
+
+class ReserveUpdate(BaseModel):
+    id_reserva:int
+    cliente:str
+    fecha:date
+    hora:time
+
+class ReserveUpdateTarifa(BaseModel):
+    id_reserva: int
+    id_tarifa:int

schemas/TarifaSh.py

@@ -0,0 +1,24 @@
+from pydantic import BaseModel
+from datetime import datetime
+
+# Clase para reutilzar en algunos casos
+class TarifaBase(BaseModel):
+    id_tarifa:int
+    
+# Esquema para recibir datos para hacer un Create
+class TarifaCreate(BaseModel):
+    descripcion:str
+    costo:int
+    
+# Esquema para recibir datos para hacer un Update
+class TarifaUpdate(TarifaBase):
+    descripcion:str
+    costo:int
+
+
+# Esquema para enviar datos
+class TarifaRead(TarifaBase):
+    descripcion:str
+    costo:int
+    estado_tarifa:bool
+    created_at:datetime

schemas/UsuarioSh.py

@@ -0,0 +1,42 @@
+from pydantic import BaseModel,EmailStr
+from enum import Enum as PydanticEnum
+from typing import Optional
+class UserRole(str,PydanticEnum):
+    SUPERADMIN = 'SUPERADMIN'
+    BARBERO = 'BARBERO'
+
+class UserBase(BaseModel):
+    correo:EmailStr
+
+class UserCreate(UserBase):
+    contrasenia:str
+
+class UserRead(UserBase):
+    id_usuario :str
+    rol:UserRole
+    estado_usuario : bool
+    
+class UserCurrent(UserBase):
+    id_usuario:str
+    rol: UserRole
+    contrasenia:str
+    estado_usuario: bool
+    
+class UserUpdate(UserBase):
+    id_usuario: str
+    contraActual:Optional[str]
+    contrasenia:Optional[str]
+    
+class UserUpdateStatus(BaseModel):
+    user_id: str
+    estado_usuario: bool
+
+class Token(UserBase):
+    access_token:str
+    token_type:str
+    rol:UserRole
+    class Config:
+        from_attributes = True
+
+    # Cuando orm_mode esta habilitado, permite la conversion directa de objetos SQLAlchemy a modelos Pydantic sin necesidad de definir explicitamente todos los campos
+

toma_de_requerimientos.txt

@@ -0,0 +1,19 @@
+Objetivo principal control de reservas, ingresos (x fechas),gastos (x fechas) y tarifas 
+
+El usuario tendra 2 roles SUPERADMIN y ADMIN
+
+El SUPERADMIN tendra unicamente el control de los usuarios ADMIN
+
+EL ADMIN tendra todos los servicios del Objetivo principal e ingreso al sistema
+
+
+Tarifas: Hace referencia a los diferentes precios que maneja la barberia, por ejm las tarifas del parqueadero
+
+Reservas: Son las agendaciones de las personas donde se lleva nombre del cliente, fecha y hora, quedaria con un estado en
+pendiente, cuando quiera cambiar el estado a finalizado debera seleccionar la tarifa, solo los clientes con estado en
+finalizado contara con ingreso
+
+Ingresos: Son las ganancias que tendra el ADMIN(barbero) administrado por fechas, es decir puede mirar los ingresos del dia,
+semana,mes y año. Teniendo en cuenta los gastos filtrados por las fechas especificas
+
+Gastos: Gastos generales que tendra el ADMIN, que se restaran a los ingresos, controlado por fechas