app.py

@@ -1,62 +1,18 @@
 from flask import Flask
 from models import db
 from flask_migrate import Migrate
-from routes.userRoutes import userRoutes
-from routes.eventRoutes import eventRoutes
+from routes import api
 import config
-from flask_jwt_extended import JWTManager
-from middlewares.errorHandlers import handle_auth_error, handle_invalid_token
-from flask_jwt_extended.exceptions import NoAuthorizationError
-from jwt.exceptions import InvalidTokenError
-from datetime import timedelta
+from celery_utils import make_celery
 
-class App:
-    def __init__(self):
-        self.app = Flask(__name__)
-        self.set_config()
-        self.set_up_db()
-        self.set_up_jwt()
-        self.register_blueprints()
-        self.setup_error_handlers()
-
-    def set_config(self):
-        self.app.config.from_object(config.Config)
-
-    def set_up_db(self):
-        db.init_app(self.app)
-        self.migrate = Migrate(self.app, db)
-
-    def setup_error_handlers(self):
-        self.app.register_error_handler(NoAuthorizationError, handle_auth_error)
-        self.app.register_error_handler(InvalidTokenError, handle_invalid_token)
-
-    def set_up_jwt(self):
-        self.jwt_manager = JWTManager(self.app)
-        self.app.config['JWT_TOKEN_LOCATION'] = ['cookies']
-        self.app.config['JWT_COOKIE_NAME'] = 'access_token_cookie'
-        self.app.config['JWT_COOKIE_CSRF_PROTECT'] = False
-        self.app.config['JWT_ACCESS_TOKEN_EXPIRES'] = timedelta(days=30)
-
-    def register_blueprints(self):
-        self.app.register_blueprint(userRoutes, url_prefix='/user')
-        self.app.register_blueprint(eventRoutes, url_prefix='/event')
-
-    def run(self):
-        with self.app.app_context():
-            db.create_all()
-        self.app.run(debug=True)
-
-    def print_endpoints(self):
-        print("Endpoints and their functions:")
-        for rule in self.app.url_map.iter_rules():
-            print(f"Endpoint: {rule.endpoint}, Path: {rule}")
-            function_name = self.app.view_functions[rule.endpoint].__name__
-            print(f"   Function: {function_name}")
-
-
-app_class_instance = App()
-app_instance = app_class_instance.app
+app = Flask(__name__)
+app.config.from_object(config.Config)
+db.init_app(app)
+migrate = Migrate(app, db)
+celery = make_celery(app)
+app.register_blueprint(api)
 
 if __name__ == '__main__':
-    app_class_instance.print_endpoints()
-    app_class_instance.run()
+    with app.app_context():
+        db.create_all()
+    app.run(debug=True)

config.py

@@ -1,3 +1,2 @@
 class Config:
     SQLALCHEMY_DATABASE_URI = 'sqlite:///events.db'
-    JWT_SECRET_KEY = 'your_jwt_secret_key'

middlewares.py

@@ -1,7 +1,6 @@
 from functools import wraps
 from flask import request, jsonify
 from datetime import datetime
-from flask_jwt_extended import jwt_required, get_jwt_identity
 
 def validate_event_post_request(f):
     @wraps(f)
@@ -22,11 +21,10 @@ def validate_event_post_request(f):
         # Validate 'description'
         if not isinstance(data['description'], str):
             return jsonify({"message": "Invalid description"}), 400
+
         # Validate 'time' (ensure it's a valid datetime string)
         try:
-            time = datetime.strptime(data['duedate'], '%Y-%m-%dT%H:%M:%S')
-            if(time < datetime.now()):
-                return jsonify({"message": "Invalid time"}), 400
+            datetime.strptime(data['duedate'], '%Y-%m-%dT%H:%M:%S')
         except ValueError:
             return jsonify({"message": "Invalid time format. Use YYYY-MM-DDTHH:MM:SS"}), 400
 

middlewares/errorHandlers.py

@@ -1,11 +0,0 @@
-from functools import wraps
-from flask import request, jsonify
-
-def handle_auth_error(e):
-    return jsonify({"error": "Please login"}), 401
-
-def handle_invalid_token(e):
-    return jsonify({"error": "Invalid session token"}), 401
-
-def handle_invalid_header_error(e):
-    return jsonify({"error": "Please login again"}), 401

middlewares/userMiddlewares.py

@@ -1,73 +0,0 @@
-from functools import wraps
-from flask import request, jsonify, g
-from flask_jwt_extended import jwt_required, get_jwt_identity
-
-def validate_user_post_request(f):
-    @wraps(f)
-    def decorated_function(*args, **kwargs):
-        data = request.get_json()
-        if not data:
-            return jsonify({"message": "No input data provided"}), 400
-
-        # Check required fields
-        required_fields = ['username', 'password', 'email', 'location']
-        if not all(field in data for field in required_fields):
-            return jsonify({"message": "Please check your data, you missing some props; visit our docs https://git.dayanhub.com/kfir"}), 400
-
-        # Validate 'username'
-        if not isinstance(data['username'], str) or not data['username'].strip():
-            return jsonify({"message": "Invalid username"}), 400
-
-        # Validate 'password'
-        if not isinstance(data['password'], str) or not data['password'].strip():
-            return jsonify({"message": "Invalid password"}), 400
-
-        # Validate 'email'
-        if not isinstance(data['email'], str) or not data['email'].strip():
-            return jsonify({"message": "Invalid email"}), 400
-        
-        # Validate 'location'
-        if not isinstance(data['location'], str) or not data['location'].strip():
-            return jsonify({"message": "Invalid location"}), 400
-
-        return f(*args, **kwargs)
-    return decorated_function
-
-
-def validate_user_login_request(f):
-    @wraps(f)
-    def decorated_function(*args, **kwargs):
-        data = request.get_json()
-        if not data:
-            return jsonify({"message": "No input data provided"}), 400
-
-        # Check required fields
-        required_fields = ['email', 'password']
-        if not all(field in data for field in required_fields):
-            return jsonify({"message": "Please check your data, you missing some props; visit our docs https://git.dayanhub.com/kfir"}), 400
-
-        # Validate 'email'
-        if not isinstance(data['email'], str) or not data['email'].strip():
-            return jsonify({"message": "Invalid email"}), 400
-
-        # Validate 'password'
-        if not isinstance(data['password'], str) or not data['password'].strip():
-            return jsonify({"message": "Invalid password"}), 400
-
-        return f(*args, **kwargs)
-    return decorated_function
-
-def authenticate_user(f):
-    @wraps(f)
-    @jwt_required(locations=["cookies"])  # Specify to look for the token in cookies
-    def decorated_function(*args, **kwargs):
-        # Get user identity from JWT
-        user_id = get_jwt_identity()
-        if user_id:
-            g.user_id = user_id
-        else:
-            return jsonify({"error": "Invalid session token"}), 401
-
-        return f(*args, **kwargs)
-    return decorated_function
-

migrations/versions/5569d39a87cf_initial_migration.py

@@ -0,0 +1,42 @@
+"""initial migration
+
+Revision ID: 5569d39a87cf
+Revises: 
+Create Date: 2024-01-04 13:44:40.811421
+
+"""
+from alembic import op
+import sqlalchemy as sa
+
+
+# revision identifiers, used by Alembic.
+revision = '5569d39a87cf'
+down_revision = None
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+    # ### commands auto generated by Alembic - please adjust! ###
+    with op.batch_alter_table('event', schema=None) as batch_op:
+        batch_op.add_column(sa.Column('title', sa.String(length=100), nullable=False))
+        batch_op.add_column(sa.Column('description', sa.String(length=200), nullable=True))
+        batch_op.add_column(sa.Column('location', sa.String(length=100), nullable=True))
+        batch_op.add_column(sa.Column('deleted', sa.Boolean(), nullable=True))
+        batch_op.add_column(sa.Column('duedate', sa.DateTime(), nullable=True))
+        batch_op.add_column(sa.Column('created_at', sa.DateTime(), nullable=True))
+
+    # ### end Alembic commands ###
+
+
+def downgrade():
+    # ### commands auto generated by Alembic - please adjust! ###
+    with op.batch_alter_table('event', schema=None) as batch_op:
+        batch_op.drop_column('created_at')
+        batch_op.drop_column('duedate')
+        batch_op.drop_column('deleted')
+        batch_op.drop_column('location')
+        batch_op.drop_column('description')
+        batch_op.drop_column('title')
+
+    # ### end Alembic commands ###

migrations/versions/bb3a88007475_initial_migration.py

@@ -1,49 +0,0 @@
-"""initial migration
-
-Revision ID: bb3a88007475
-Revises: 
-Create Date: 2024-01-07 14:12:47.164418
-
-"""
-from alembic import op
-import sqlalchemy as sa
-
-
-# revision identifiers, used by Alembic.
-revision = 'bb3a88007475'
-down_revision = None
-branch_labels = None
-depends_on = None
-
-
-def upgrade():
-    # ### commands auto generated by Alembic - please adjust! ###
-    op.create_table('user',
-    sa.Column('id', sa.String(length=36), nullable=False),
-    sa.Column('name', sa.String(length=100), nullable=True),
-    sa.Column('email', sa.String(length=120), nullable=False),
-    sa.Column('password_hash', sa.String(length=128), nullable=True),
-    sa.Column('location', sa.String(length=100), nullable=False),
-    sa.PrimaryKeyConstraint('id'),
-    sa.UniqueConstraint('email')
-    )
-    op.create_table('event',
-    sa.Column('id', sa.Integer(), nullable=False),
-    sa.Column('title', sa.String(length=100), nullable=False),
-    sa.Column('description', sa.String(length=200), nullable=True),
-    sa.Column('location', sa.String(length=100), nullable=True),
-    sa.Column('deleted', sa.Boolean(), nullable=True),
-    sa.Column('duedate', sa.DateTime(), nullable=True),
-    sa.Column('created_at', sa.DateTime(), nullable=True),
-    sa.Column('user_id', sa.String(length=36), nullable=False),
-    sa.ForeignKeyConstraint(['user_id'], ['user.id'], ),
-    sa.PrimaryKeyConstraint('id')
-    )
-    # ### end Alembic commands ###
-
-
-def downgrade():
-    # ### commands auto generated by Alembic - please adjust! ###
-    op.drop_table('event')
-    op.drop_table('user')
-    # ### end Alembic commands ###

models.py

@@ -1,16 +1,6 @@
 from flask_sqlalchemy import SQLAlchemy
-from flask_bcrypt import Bcrypt
-from sqlalchemy import Table, Column, Integer, ForeignKey, String
-import uuid
 
 db = SQLAlchemy()
-bcrypt = Bcrypt()
-
-
-user_event_association = Table('user_event', db.Model.metadata,
-    Column('user_id', String(36), ForeignKey('user.id')),
-    Column('event_id', Integer, ForeignKey('event.id'))
-)
 
 class Event(db.Model):
     id = db.Column(db.Integer, primary_key=True)
@@ -20,9 +10,6 @@ class Event(db.Model):
     deleted = db.Column(db.Boolean, default=False)
     duedate = db.Column(db.DateTime)
     created_at = db.Column(db.DateTime, default=db.func.now())
-    user_id = db.Column(db.String(36), db.ForeignKey('user.id'), nullable=False)
-    users = db.relationship('User', secondary=user_event_association, back_populates='events')
-
 
     def to_dict(self):
         return {
@@ -31,31 +18,5 @@ class Event(db.Model):
             'description': self.description,
             'location': self.location,
             'duedate': self.duedate.isoformat() if self.duedate else None,
-            'created_at': self.created_at.isoformat(),
-            'user_id': self.user_id
+            'created_at': self.created_at.isoformat()
         }
-
-class User(db.Model):
-    id = db.Column(db.String(36), primary_key=True, default=lambda: str(uuid.uuid4()))
-    name = db.Column(db.String(100))
-    email = db.Column(db.String(120), unique=True, nullable=False)
-    password_hash = db.Column(db.String(128))
-    location = db.Column(db.String(100), nullable=False)
-    events = db.relationship('Event', secondary=user_event_association, back_populates='users')
-
-
-
-    def set_password(self, password):
-        self.password_hash = bcrypt.generate_password_hash(password).decode('utf-8')
-
-    def check_password(self, password):
-        return bcrypt.check_password_hash(self.password_hash, password)
-
-    def to_dict(self):
-        return {
-            'id': self.id,
-            'name': self.name,
-            'email': self.email,
-            'location': self.location
-        }
-    

routes.py

@@ -0,0 +1,61 @@
+from flask import Blueprint, jsonify, request
+from services import EventService
+from middlewares import validate_event_post_request
+
+api = Blueprint('api', __name__)
+
+# Create new event
+@api.route('/events', methods=['POST'])
+@validate_event_post_request
+def create_event():
+    try: 
+        data = request.json
+        new_event = EventService.create_event(data)
+        if new_event:
+            return jsonify(new_event.to_dict()), 201
+        else:
+            return jsonify({'error': 'Failed to create event'}), 400
+    except Exception as e:
+        return jsonify({'error': str(e)}), 500
+
+# Get All Events
+@api.route('/events', methods=['GET'])
+def get_events():
+    try:
+        return {"events": EventService.get_all_events()}, 200
+    except Exception as e:
+        return {"error": str(e)}, 500
+    
+# Get Event by ID
+@api.route('/events/<int:event_id>', methods=['GET'])
+def get_event(event_id):
+    try:
+        return {"event": EventService.get_event_by_id(event_id)}, 200
+    except Exception as e:
+        return {"error": str(e)}, 500
+
+# Update Event
+@api.route('/events/<int:event_id>', methods=['PUT'])
+@validate_event_post_request
+def update_event(event_id):
+    try:
+        data = request.json
+        updated_event = EventService.update_event(event_id, data)
+        if updated_event:
+            return jsonify(updated_event.to_dict()), 200
+        else:
+            return jsonify({'error': 'Failed to update event'}), 400
+    except Exception as e:
+        return jsonify({'error': str(e)}), 500
+    
+# DELETE Event
+@api.route('/events/<int:event_id>', methods=['DELETE'])
+def delete_event(event_id):
+    try:
+        deleted_event = EventService.delete_event(event_id)
+        if deleted_event:
+            return jsonify(deleted_event.to_dict()), 200
+        else:
+            return jsonify({'error': 'Failed to delete event'}), 400
+    except Exception as e:
+        return jsonify({'error': str(e)}), 500

routes/eventRoutes.py

@@ -1,94 +0,0 @@
-from flask import Blueprint, jsonify, request, g
-from services.EventService import EventService
-from middlewares.userMiddlewares import authenticate_user
-from middlewares.eventMiddlewares import validate_event_post_request
-
-eventRoutes = Blueprint('eventRoutes', __name__)
-
-# Create new event
-@eventRoutes.route('/', methods=['POST'])
-@eventRoutes.route('', methods=['POST'])
-@validate_event_post_request
-@authenticate_user
-def create_event():
-    try: 
-        data = request.json
-        data['user_id'] = g.user_id
-        new_event = EventService.create_event(data)
-        if new_event:
-            return jsonify(new_event.to_dict()), 201
-        else:
-            return jsonify({'error': 'Failed to create event'}), 400
-    except Exception as e:
-        return jsonify({'error': str(e)}), 500
-
-# Get All Events
-@eventRoutes.route('/', methods=['GET'])
-@eventRoutes.route('', methods=['GET'])
-@authenticate_user
-def get_events():
-    try:
-        user_events = EventService.get_upcoming_events(g.user_id)
-        return {"events": user_events, "count": len(user_events)}, 200
-    except Exception as e:
-        return {"error": str(e)}, 500
-    
-# Get Event by ID
-@eventRoutes.route('/<int:event_id>', methods=['GET'])
-@authenticate_user
-def get_event(event_id):
-    try:
-        return {"event": EventService.get_event_by_id(event_id, g.user_id)}, 200
-    except Exception as e:
-        return {"error": str(e)}, 500
-
-# Update Event
-@eventRoutes.route('/<int:event_id>', methods=['PUT'])
-@validate_event_post_request
-@authenticate_user
-def update_event(event_id):
-    try:
-        data = request.json
-        updated_event = EventService.update_event(event_id, data)
-        if updated_event:
-            return jsonify(updated_event.to_dict()), 200
-        else:
-            return jsonify({'error': 'Event not found'}), 404
-    except Exception as e:
-        return jsonify({'error': str(e)}), 500
-    
-# DELETE Event
-@eventRoutes.route('/<int:event_id>', methods=['DELETE'])
-@authenticate_user
-def delete_event(event_id):
-    try:
-        deleted_event = EventService.delete_event(event_id)
-        if deleted_event:
-            return jsonify(deleted_event.to_dict()), 200
-        else:
-            return jsonify({'error': 'Event not found'}), 404
-    except Exception as e:
-        return jsonify({'error': str(e)}), 500
-    
-
-# User atended to event with id event_id and user must be loggedin
-@eventRoutes.route('/<int:event_id>/attend', methods=['POST'])
-@authenticate_user
-def attend_event(event_id):
-    response = EventService.attend_event(event_id)
-    # Check if there's an error in the response
-    if 'error' in response:
-        return jsonify({'error': response['error']}), 400  # Or another appropriate status code
-
-    # If no error, return success response
-    return jsonify({'message': response['message']}), 200
-
-@eventRoutes.route('/<int:event_id>/unattend', methods=['POST'])
-@authenticate_user
-def unattend_event(event_id):
-    response = EventService.unattend_event(event_id)
-    # Check if there's an error in the response
-    if 'error' in response:
-        return jsonify({'error': response['error']}), 400  # Or another appropriate status code
-    
-    return jsonify({'message': response['message']}), 200

routes/userRoutes.py

@@ -1,61 +0,0 @@
-from flask import Blueprint, jsonify, request
-from services.UserService import UserService
-from flask_jwt_extended import JWTManager, jwt_required, create_access_token
-from middlewares.userMiddlewares import validate_user_post_request, validate_user_login_request
-
-userRoutes = Blueprint('userRoutes', __name__)
-
-@userRoutes.route('/', methods=['GET'])
-@userRoutes.route('', methods=['GET'])
-def allUsers():
-    users = UserService.get_all_users()
-    return jsonify(users), 200
-
-@userRoutes.route('/', methods=['POST'])
-@userRoutes.route('', methods=['POST'])
-@validate_user_post_request
-def createNewUser():
-    try:
-        data = request.json
-        if UserService.get_user_by_email(data['email']):
-            return jsonify({'error': 'User already exists'}), 400
-        new_user = UserService.create_user(data)
-        if new_user:
-            return jsonify(new_user), 201
-        else:
-            return jsonify({'error': 'Failed to create user'}), 400
-    except Exception as e:
-        return jsonify({'error': str(e)}), 500
-    
-@userRoutes.route('/login', methods=['POST'])
-@validate_user_login_request
-def loginUser():
-    try:
-        data = request.json
-        user = UserService.verify_user(data)
-        if user:
-            token = login(user)
-            response = user.to_dict()
-            response['token'] = token
-            response = jsonify(response)
-            return response, 200
-        else:
-            return jsonify({'error': 'Invalid credentials'}), 400
-    except Exception as e:
-        return jsonify({'error': str(e)}), 500
-    
-@userRoutes.route('/logout', methods=['POST'])
-@jwt_required(optional=True)
-def logoutUser():
-    try:
-        response = jsonify({'message': 'Logged out successfully'})
-        response.set_cookie('access_token_cookie', '', expires=0)
-        return response, 200
-    except Exception as e:
-        return jsonify({'error': str(e)}), 500
-        
-def login(user):
-    sessionToken = create_access_token(identity=user.id)
-    response = jsonify(user.to_dict())
-    response.set_cookie('access_token_cookie', sessionToken, httponly=True, path='/')
-    return sessionToken

services.py

@@ -0,0 +1,43 @@
+from models import db, Event
+from datetime import datetime
+
+class EventService:
+    @staticmethod
+    def create_event(data):
+        new_event = Event(
+            title=data['title'],
+            description=data.get('description', ''),
+            location=data.get('location', ''),
+            duedate=datetime.strptime(data['duedate'], '%Y-%m-%dT%H:%M:%S')
+        )
+        db.session.add(new_event)
+        db.session.commit()
+        return new_event
+
+    @staticmethod
+    def get_all_events():
+        events=Event.query.filter_by(deleted=False).all()
+        return [event.to_dict() for event in events]
+
+    @staticmethod
+    def get_event_by_id(event_id):
+        return Event.query.filter_by(id=event_id, deleted=False).first().to_dict()
+    @staticmethod
+    def update_event(event_id, data):
+        event = Event.query.get(event_id)
+        event.title = data['title']
+        event.description = data.get('description', '')
+        event.location = data.get('location', '')
+        event.time = datetime.strptime(data['duedate'], '%Y-%m-%dT%H:%M:%S')
+        db.session.commit()
+        return event
+    
+    @staticmethod
+    def delete_event(event_id):
+        event = Event.query.filter_by(id=event_id, deleted=False).first()
+        if event:
+            event.deleted = True
+            db.session.commit()
+        else:
+            return None
+        return event

services/EventService.py

@@ -1,123 +0,0 @@
-from sqlalchemy.sql import exists
-from models import db, Event, user_event_association
-from services.UserService import UserService
-from datetime import datetime
-from flask import g
-
-class EventService:
-    @staticmethod
-    def create_event(data):
-        new_event = Event(
-            title=data['title'],
-            description=data.get('description', ''),
-            location=data.get('location', ''),
-            duedate=datetime.strptime(data['duedate'], '%Y-%m-%dT%H:%M:%S'),
-            user_id=data['user_id']
-        )
-        db.session.add(new_event)
-        db.session.commit()
-        return new_event
-
-    @staticmethod
-    def get_upcoming_events(user_id):
-        events=Event.query.filter_by(deleted=False).all()
-        if(events):
-            return [event.to_dict() for event in events]
-        else:
-            return []
-
-    @staticmethod
-    def get_event_by_id(event_id, user_id):
-        event = Event.query.filter_by(id=event_id,user_id=user_id, deleted=False).first()
-        if(event):
-            return event.to_dict()
-        else:
-            return []
-    
-    @staticmethod
-    def update_event(event_id, data):
-        event = Event.query.get(event_id)
-        if not event:
-            return None
-        event.title = data['title']
-        event.description = data.get('description', '')
-        event.location = data.get('location', '')
-        event.time = datetime.strptime(data['duedate'], '%Y-%m-%dT%H:%M:%S')
-        db.session.commit()
-        return event
-    
-    @staticmethod
-    def delete_event(event_id):
-        event = Event.query.filter_by(id=event_id, deleted=False).first()
-        if event:
-            event.deleted = True
-            db.session.commit()
-        else:
-            return None
-        return event
-
-
-    @staticmethod
-    def attend_event(event_id):
-        user_id = g.user_id  # Assuming user_id is stored in Flask's global g object
-        # Check if the event is valid and in the future
-        event = Event.query.filter(
-            Event.id == event_id,
-            Event.duedate > datetime.now(),
-            Event.deleted == False
-        ).first()
-
-        if not event:
-            return {'error': 'Event not found or already passed'}
-
-        # Check if the user is already associated with the event
-        is_already_attending = db.session.query(exists().where(
-            user_event_association.c.user_id == user_id,
-            user_event_association.c.event_id == event_id
-        )).scalar()
-
-        if is_already_attending:
-            return {'error': 'User already attending this event'}
-
-        # Add the user to the event
-        user = UserService.get_user_by_id(user_id)
-        if not user:
-            return {'error': 'User not found'}
-
-        event.users.append(user)
-        db.session.commit()
-
-        return {'message': 'User successfully added to the event'}
-
-
-    @staticmethod
-    def unattend_event(event_id):
-        user_id = g.user_id  # Assuming user_id is stored in Flask's global g object
-        # Check if the event is valid and in the future
-        event = Event.query.filter(
-            Event.id == event_id,
-            Event.duedate > datetime.now(),
-            Event.deleted == False
-        ).first()
-
-        if not event:
-            return {'error': 'Event not found or already passed'}
-
-        # Check if the user is already associated with the event
-        is_already_attending = db.session.query(exists().where(
-            user_event_association.c.user_id == user_id,
-            user_event_association.c.event_id == event_id
-        )).scalar()
-
-        if not is_already_attending:
-            return {'error': 'User not attending this event'}
-
-        # Remove the user from the event
-        user = UserService.get_user_by_id(user_id)
-        if not user:
-            return {'error': 'User not found'}
-
-        event.users.remove(user)
-        db.session.commit()
-
-        return {'message': 'User successfully removed from the event'}

services/UserService.py

@@ -1,37 +0,0 @@
-from flask_bcrypt import Bcrypt
-from models import db, User
-
-bcrypt = Bcrypt()
-
-class UserService:
-    @staticmethod
-    def create_user(data):
-        new_user = User(
-            name=data['username'],
-            email=data['email'],
-            location=data['location'],
-            password_hash=bcrypt.generate_password_hash(data['password']).decode('utf-8')
-        )
-        db.session.add(new_user)
-        db.session.commit()
-        return new_user.to_dict()
-
-    @staticmethod
-    def get_all_users():
-        users = User.query.all()
-        return [user.to_dict() for user in users]
-
-    @staticmethod
-    def get_user_by_email(email):
-        return User.query.filter_by(email=email).first()
-    
-    @staticmethod
-    def get_user_by_id(user_id):
-        return User.query.get(user_id)
-
-    @staticmethod
-    def verify_user(data):
-        user = UserService.get_user_by_email(data['email'])
-        if user and bcrypt.check_password_hash(user.password_hash, data['password']):
-            return user
-        return None