es-user 0.1.0__tar.gz

es_user-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Babafemi Adigun
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

es_user-0.1.0/PKG-INFO

@@ -0,0 +1,18 @@
+Metadata-Version: 2.1
+Name: es-user
+Version: 0.1.0
+Summary: user management for ESSL apps
+License: MIT
+Author: Femi Adigun
+Author-email: femi.adigun@myeverlasting.net
+Requires-Python: >=3.9,<4.0
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Description-Content-Type: text/markdown
+
+# Internal User Management package for ESSL apps
+

es_user-0.1.0/README.md

@@ -0,0 +1 @@
+# Internal User Management package for ESSL apps

es_user-0.1.0/es_user/contact/model.py

@@ -0,0 +1,28 @@
+"""Copyright 2024 Everlasting Systems and Solutions LLC (www.myeverlasting.net).
+All Rights Reserved.
+
+No part of this software or any of its contents may be reproduced, copied, modified or adapted, without the prior written consent of the author, unless otherwise indicated for stand-alone materials.
+
+For permission requests, write to the publisher at the email address below:
+office@myeverlasting.net
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+"""
+from sqlalchemy import Column, DateTime
+from sqlalchemy.sql import func
+from sqlalchemy.sql.sqltypes import Integer,String
+from es_user.db.session import Base
+class Lead(Base):
+    __tablename__ = "leads"
+    id = Column(Integer, primary_key=True, index=True, autoincrement=True)
+    created_at = Column(DateTime(), server_default=func.now())
+    first_name = Column(String)
+    last_name = Column(String)
+    email = Column(String, nullable=False)
+    phone_number = Column(String)
+    country = Column(String)
+    subject = Column(String)
+    message = Column(String)
+    created_at = Column(DateTime(), server_default=func.now())
+    updated_at = Column(DateTime(), server_default=func.now(), onupdate=func.now())

es_user-0.1.0/es_user/contact/schema.py

@@ -0,0 +1,27 @@
+"""Copyright 2024 Everlasting Systems and Solutions LLC (www.myeverlasting.net).
+All Rights Reserved.
+
+No part of this software or any of its contents may be reproduced, copied, modified or adapted, without the prior written consent of the author, unless otherwise indicated for stand-alone materials.
+
+For permission requests, write to the publisher at the email address below:
+office@myeverlasting.net
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+"""
+from datetime import datetime,date
+from pydantic import BaseModel, EmailStr
+
+class LeadBase(BaseModel):
+    first_name: str
+    last_name: str
+    email: EmailStr
+    phone_number: str | None = None
+    subject: str | None = None
+    message: str | None = None
+    created_at: datetime = datetime.now()
+class LeadDto(LeadBase):
+    id: int
+class LeadFiter(BaseModel):
+    start_date: date
+    end_date: date

es_user-0.1.0/es_user/contact/service.py

@@ -0,0 +1,37 @@
+"""Copyright 2024 Everlasting Systems and Solutions LLC (www.myeverlasting.net).
+All Rights Reserved.
+
+No part of this software or any of its contents may be reproduced, copied, modified or adapted, without the prior written consent of the author, unless otherwise indicated for stand-alone materials.
+
+For permission requests, write to the publisher at the email address below:
+office@myeverlasting.net
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+"""
+import logging
+from sqlalchemy.orm import Session
+from es_user.contact.schema import LeadDto,LeadBase
+from es_user.contact.model import Lead
+from es_user.db import pg
+from datetime import datetime
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+def make_contact_form(lead: LeadBase,db: Session) -> LeadDto:
+    """Submits a contact form.
+    Args:
+        lead (LeadDto): Lead form content.
+        db (Session): Database session.
+    """
+    try:
+        new_lead = pg.add_model(Lead,db, **lead.model_dump())
+    except Exception as e:
+        raise e
+    return LeadDto(**new_lead.__dict__)
+def all_leads(db: Session) -> list[LeadDto]:
+    leads = db.query(Lead).all()
+    return [LeadDto(**lead.__dict__) for lead in leads]
+def leads_by_created(start_date: datetime, end_date: datetime, db: Session) -> list[LeadDto]:
+    leads = db.query(Lead).filter(Lead.created_at >= start_date, Lead.created_at <= end_date).all()
+    return [LeadDto(**lead.__dict__) for lead in leads]

es_user-0.1.0/es_user/db/pg.py

@@ -0,0 +1,171 @@
+"""Copyright 2024 Everlasting Systems and Solutions LLC (www.myeverlasting.net).
+All Rights Reserved.
+
+No part of this software or any of its contents may be reproduced, copied, modified or adapted, without the prior written consent of the author, unless otherwise indicated for stand-alone materials.
+
+For permission requests, write to the publisher at the email address below:
+office@myeverlasting.net
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+"""
+from typing import Type,Any
+from sqlalchemy.exc import IntegrityError,SQLAlchemyError
+from sqlalchemy.orm import Session
+import logging
+logger = logging.getLogger(__name__)
+def add_model(model_class: Type, db: Session, **kwargs):
+    """
+    Persist a SQLAlchemy model to the database.
+
+    Args:
+    - model_class (Type): The SQLAlchemy model class to be persisted.
+    - db (Session): The database session to use for persistence.
+    - **kwargs: Keyword arguments to pass to the model constructor.
+
+    Returns:
+    - bool: True if the model is persisted successfully, False otherwise.
+
+    Raises:
+    - IntegrityError: If the model cannot be persisted due to an integrity error.
+    """
+    try:
+        new_model = model_class(**kwargs)
+        db.add(new_model)
+        db.commit()
+        db.refresh(new_model)
+        return new_model
+    except IntegrityError as e:
+        db.rollback()
+        error_msg = f"Integrity Error when adding {model_class.__name__}: {str(e)}"
+        logger.error(error_msg)
+        raise ValueError(error_msg) from e
+    except SQLAlchemyError as e:
+        db.rollback()
+        error_msg = f"Database Error when adding {model_class.__name__}: {str(e)}"
+        logger.error(error_msg)
+        raise ValueError(error_msg) from e
+    except Exception as e:
+        db.rollback()
+        error_msg = f"Unexpected error when adding {model_class.__name__}: {str(e)}"
+        logger.error(error_msg)
+        raise ValueError(error_msg) from e
+def update_model(model_class: Type, db: Session, model_id: int, **kwargs) -> bool:
+    """
+    Update a SQLAlchemy model in the database.
+
+    Args:
+    - model_class (Type): The SQLAlchemy model class to be updated.
+    - db (Session): The database session to use for updating.
+    - id (int): The ID of the model instance to be updated.
+    - **kwargs: Keyword arguments with the attributes to be updated and their new values.
+
+    Returns:
+    - model: The updatd model.
+
+    Raises:
+    - Exception: If an error occurs during the update process.
+    """
+    try:
+        model = db.query(model_class).get(model_id)
+        if not model:
+            raise ValueError(f"{model_class.__name__} with id {model_id} not found.")
+
+        for key, value in kwargs.items():
+            if hasattr(model, key) and key != 'id':
+                setattr(model, key, value)
+
+        db.commit()
+        db.refresh(model)
+        return model
+        
+    except SQLAlchemyError as e:
+        logger.error(f"Error updating {model_class.__name__}: {e}")
+        db.rollback()
+        raise ValueError(f"Database error: {str(e)}")
+    except Exception as e:
+        logger.error(f"Unexpected error: {e}")
+        db.rollback()
+        raise ValueError(f"Unexpected error: {str(e)}")
+
+def get_model(model_class: Type, db: Session, id: int) -> object:
+    """
+    Retrieve a SQLAlchemy model instance from the database by ID.
+
+    Args:
+    - model_class (Type): The SQLAlchemy model class to be retrieved.
+    - db (Session): The database session to use for retrieval.
+    - id (int): The ID of the model instance to be retrieved.
+
+    Returns:
+    - object: The retrieved model instance, or None if not found.
+    """
+    return db.query(model_class).filter_by(id=id).first()
+def get_model_by_field(model_class: Type, db: Session, field: str, value: Any) -> object:
+    """
+    Retrieve a SQLAlchemy model instance from the database by a specified field and value.
+
+    Args:
+    - model_class (Type): The SQLAlchemy model class to be retrieved.
+    - db (Session): The database session to use for retrieval.
+    - field (str): The field name to filter by.
+    - value (Any): The value of the field to filter by.
+
+    Returns:
+    - object: The retrieved model instance, or None if not found.
+    """
+    return db.query(model_class).filter(getattr(model_class, field) == value).first()
+def get_models_by_field(model_class: Type, db: Session, field: str, value: str) -> list[object]:
+    """
+    Retrieve a SQLAlchemy model instance from the database by a specific field.
+
+    Args:
+    - model_class (Type): The SQLAlchemy model class to be retrieved.
+    - db (Session): The database session to use for retrieval.
+    - field (str): The field to search for.
+    - value (str): The value to search for.
+
+    Returns:
+    - List[object]: A list of all instances of the specified model class that match the search criteria.
+    """
+    return db.query(model_class).filter(getattr(model_class, field) == value).all()
+
+def get_all_models(model_class: Type, db: Session) -> list:
+    """
+    Retrieve all instances of a SQLAlchemy model from the database.
+
+    Args:
+    - model_class (Type): The SQLAlchemy model class to be retrieved.
+    - db (Session): The database session to use for retrieval.
+
+    Returns:
+    - list: A list of all instances of the specified model class.
+    """
+    return db.query(model_class).all()
+
+def delete_model(model_class: Type, db: Session, id: int) -> bool:
+    """
+    Delete a SQLAlchemy model instance from the database by ID.
+
+    Args:
+    - model_class (Type): The SQLAlchemy model class to be deleted.
+    - db (Session): The database session to use for deletion.
+    - id (int): The ID of the model instance to be deleted.
+
+    Returns:
+    - bool: True if the model is deleted successfully, False otherwise.
+
+    Raises:
+    - Exception: If an error occurs during the deletion process.
+    """
+    try:
+        model = db.query(model_class).get(id)
+        if not model:
+            raise ValueError(f"{model_class.__name__} with id {id} not found.")
+        db.delete(model)
+        db.commit()
+        return True
+    except Exception as e:
+        db.rollback()
+        logger.error(f"Error: {e}")
+        raise ValueError(str(e)) from e

es_user-0.1.0/es_user/db/session.py

@@ -0,0 +1,17 @@
+"""Copyright 2024 Everlasting Systems and Solutions LLC (www.myeverlasting.net).
+All Rights Reserved.
+
+No part of this software or any of its contents may be reproduced, copied, modified or adapted, without the prior written consent of the author, unless otherwise indicated for stand-alone materials.
+
+For permission requests, write to the publisher at the email address below:
+office@myeverlasting.net
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+"""
+from es_user.util.CONSTANTS import SCHEMA
+from sqlalchemy import MetaData
+from sqlalchemy.orm import declarative_base
+
+metadata = MetaData(schema=SCHEMA)
+Base = declarative_base(metadata=metadata)

es_user-0.1.0/es_user/user/model.py

@@ -0,0 +1,54 @@
+"""Copyright 2024 Everlasting Systems and Solutions LLC (www.myeverlasting.net).
+All Rights Reserved.
+
+No part of this software or any of its contents may be reproduced, copied, modified or adapted, without the prior written consent of the author, unless otherwise indicated for stand-alone materials.
+
+For permission requests, write to the publisher at the email address below:
+office@myeverlasting.net
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+"""
+from sqlalchemy import Column, DateTime, ForeignKey, Enum
+from sqlalchemy.sql import func
+from sqlalchemy.sql.sqltypes import Integer,String,Boolean
+from sqlalchemy.dialects.postgresql import ARRAY
+from sqlalchemy.orm import relationship
+from es_user.db.session import Base
+from es_user.util.enums import AccessRoleEnum,StatusEnum
+from es_user.util.CONSTANTS import SCHEMA
+class Address(Base):
+    __tablename__ = "addresses"
+    id = Column(Integer, primary_key=True, index=True, autoincrement=True)
+    street = Column(String)
+    city = Column(String)
+    state = Column(String)
+    zip_code = Column(String)
+    email = Column(String)
+    phone_number = Column(String)
+    country = Column(String)
+
+
+class Appuser(Base):
+    __tablename__ = "appusers"
+    id = Column(Integer, primary_key=True, index=True, autoincrement=True)
+    first_name = Column(String)
+    last_name = Column(String)
+    country = Column(String)
+    email = Column(String, nullable=False, unique=True)
+    password = Column(String)
+    token = Column(String)
+    dp = Column(String)
+    is_active = Column(Boolean)
+    roles = Column(ARRAY(Enum(AccessRoleEnum, schema=SCHEMA)))
+    status = Column(Enum(StatusEnum, schema=SCHEMA))
+    gender = Column(String)
+    socialmedia = Column(String)
+    created_at = Column(DateTime(), server_default=func.now())
+    updated_at = Column(DateTime(), server_default=func.now(), onupdate=func.now())
+    address_id = Column(
+        Integer, ForeignKey("addresses.id"), nullable=True
+    ) 
+    address = relationship(
+        "Address", uselist=False, backref="user"
+    ) 

es_user-0.1.0/es_user/user/schema.py

@@ -0,0 +1,69 @@
+"""Copyright 2024 Everlasting Systems and Solutions LLC (www.myeverlasting.net).
+All Rights Reserved.
+
+No part of this software or any of its contents may be reproduced, copied, modified or adapted, without the prior written consent of the author, unless otherwise indicated for stand-alone materials.
+
+For permission requests, write to the publisher at the email address below:
+office@myeverlasting.net
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+"""
+from datetime import datetime
+from pydantic import BaseModel, EmailStr, field_validator
+from es_user.util.enums import AccessRoleEnum, StatusEnum
+from typing import Literal
+gender_type = Literal['MALE', 'FEMALE', 'OTHER']
+class AddressBase(BaseModel):
+    street: str
+    city: str
+    state: str
+    zip_code: str | None = None
+    email: EmailStr | None = None
+    phone_number: str | None = None
+    country: str
+class AddressDto(AddressBase):
+    id: int | None = None
+class UserEmail(BaseModel):
+    email: EmailStr
+class UserReset(UserEmail):
+    token: str
+    password: str
+    new_password: str | None = None
+class UserPhoto(BaseModel):
+    file_path: str
+    user_id: int
+class UserBase(BaseModel):
+    first_name: str
+    last_name: str
+    is_active: bool = False
+    roles: list[AccessRoleEnum]
+    socialmedia: str | None = None # comma separated string
+    gender: gender_type
+    token: str | None = None
+    email: EmailStr
+    status: StatusEnum = StatusEnum.NEW
+
+class UserResponse(UserBase):
+    id: int
+    dp: str | None = None
+    created_at: datetime = datetime.now()
+
+    @field_validator('roles')
+    def validate_roles(cls, roles):
+        if AccessRoleEnum.GUEST in roles and AccessRoleEnum.ADMIN in roles:
+            raise ValueError("User cannot have roles of Guest and Admin at the same time")
+        return roles
+
+class AppuserDto(UserBase):
+    password: str
+    address: AddressBase | None = None
+
+class AppuserUpdate(UserBase):
+    id: int  
+    address: AddressDto | None = None 
+    @field_validator('roles')
+    def validate_roles(cls, roles):
+        if AccessRoleEnum.GUEST in roles and AccessRoleEnum.ADMIN in roles:
+            raise ValueError("User cannot have roles of Guest and Admin at the same time")
+        return roles

es_user-0.1.0/es_user/user/service.py

@@ -0,0 +1,334 @@
+"""Copyright 2024 Everlasting Systems and Solutions LLC (www.myeverlasting.net).
+All Rights Reserved.
+
+No part of this software or any of its contents may be reproduced, copied, modified or adapted, without the prior written consent of the author, unless otherwise indicated for stand-alone materials.
+
+For permission requests, write to the publisher at the email address below:
+office@myeverlasting.net
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+"""
+from sqlalchemy import desc
+from sqlalchemy.orm import Session
+from sqlalchemy.exc import SQLAlchemyError,IntegrityError
+from pydantic import EmailStr   
+from es_user.user.model import Appuser, Address
+from es_user.user.schema import AppuserDto, UserResponse, AppuserUpdate, UserReset, AddressDto
+from es_user.util.service import encrypt_pass, verify_password
+from es_user.util.enums import AccessRoleEnum, StatusEnum
+from es_user.db import pg
+import logging
+import uuid
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+def make_admin(db: Session, password: str, email: str) -> Appuser | None:
+    """Create admin user if it does not exist.
+        Args:
+            db (Session): Database session.
+            password (str): Admin password.
+            email (str): Admin email.
+    """
+    user = db.query(Appuser).filter(Appuser.email == "office@horacelearning.com").first()
+    if user:
+        logger.info("Horace Admin user already exists")
+        return
+    new_admin = AppuserDto(
+        first_name="Horace",
+        last_name="Admin",
+        email=email,
+        token="Horace@123",
+        password=encrypt_pass(password),
+        status=StatusEnum.NEW,
+        is_active=True,
+        gender="MALE",
+        roles=[AccessRoleEnum.ADMIN],
+    )
+    pg.add_model(Appuser, db, **new_admin.__dict__)
+async def add_user(user: AppuserDto, db: Session) -> UserResponse:
+    try:
+        new_user = None
+        if user.address:
+            addr = pg.add_model(Address, db, **user.address.__dict__)
+            user.address = addr
+            new_user = pg.add_model(Appuser, db, **user.__dict__)
+
+        if new_user:
+            return UserResponse(**new_user.__dict__)
+        else:
+            raise ValueError("Failed to add new user.")
+    except IntegrityError as e:
+        if "duplicate key value violates unique constraint" in str(e.orig):
+            logger.error(f"Error adding user: {e}")
+            raise ValueError(f"Email already exists. {user.email}")
+        else:
+            logger.error(f"Error adding user: {e}")
+            raise ValueError("An error occurred.")
+    except SQLAlchemyError as e:
+        logger.error(f"Error adding user: {e}")
+        raise ValueError(
+            "Database error.")
+    except Exception as e:
+        logger.error(f"Unexpected error: {e}")
+        raise ValueError(f"Unexpected error.{e}")
+
+# def bulk_upload_users(contents: bytes, file_type: str, db: Session) -> int:
+#     """
+#     Uploads user data from a CSV or JSON file.
+
+#     Args:
+#         file (IO): The file object of the CSV or JSON file.
+#         file_type (str): "csv" or "json".
+#         db (Session): The database session object.
+
+#     Returns:
+#         int: The number of users successfully uploaded.
+#     """
+#     uploaded_count = 0
+
+#     try:
+#         if file_type == "csv":
+#             data = read_csv(io.BytesIO(contents), converters={"roles": lambda x: x.split(",")})
+#             # 
+#             # records = data.to_dict(orient='records')
+#         elif file_type == "json":
+#             data = read_json(io.BytesIO(contents))
+#             # records = data.to_dict(orient='records')
+#         else:
+#             raise ValueError("Invalid file type. Supported types: csv, json")
+#         data["password"] = data["password"].apply(encrypt_pass)
+#         data["status"] = StatusEnum.NEW 
+#         records = data.to_dict(orient='records')
+#         user_dtos = [AppuserDto(**row) for row in records]
+
+#         db.bulk_insert_mappings(Appuser, [user_dto.__dict__ for user_dto in user_dtos])
+#         db.commit()
+#         uploaded_count = len(records)
+
+#     except ValueError as ve:
+#         raise ve
+#     except (csv.Error, json.JSONDecodeError) as file_error:
+#         raise Exception(f"Error reading the file: {file_error}")
+#     except Exception as e:
+#         db.rollback()
+#         raise Exception(f"Error processing user data: {e}")
+
+#     return uploaded_count
+
+def get_user_by_id(usr: int, db: Session) -> UserResponse:
+    try:
+        user = pg.get_model(Appuser, db, usr)
+        if not user:
+            raise ValueError(f"No user with id {usr}")
+        return UserResponse(**user.__dict__)
+    except Exception as e:
+        logger.error(f"Get user by id failed {str(e)}")
+        raise ValueError(f"Error getting User {usr}")
+def activate_user(email: str, db: Session) -> bool:
+    try:
+        user = db.query(Appuser).filter(Appuser.email == email).first()
+        if not user:
+            raise ValueError(f"No user with email {email}")
+        user.is_active = not user.is_active
+        db.commit()
+        return True
+    except Exception as e:
+        db.rollback()
+        logger.error(f"Error activating user {email}: {str(e)}")
+        raise ValueError(f"Error activating user {email}: {str(e)}")
+def update_user(user_update: AppuserUpdate, db: Session) -> UserResponse:
+    try:
+        existing_user = db.query(Appuser).get(user_update.id)
+        if not existing_user:
+            raise ValueError(f"User not found. {user_update.id}")
+        
+        # Update the address if provided
+        if user_update.address:
+            if existing_user.address_id:
+                addr = db.query(Address).get(existing_user.address_id)
+                for key, value in user_update.address.__dict__.items():
+                    setattr(addr, key, value)
+                addr.id = existing_user.address_id
+                db.commit()
+                db.refresh(addr)
+            else:
+                addr = Address(**user_update.address.__dict__)
+                db.add(addr)
+                db.commit()
+                db.refresh(addr)
+                existing_user.address_id = addr.id
+
+        # Update the user details
+        for key, value in user_update.__dict__.items():
+            if key != 'address' and key != 'id':
+                setattr(existing_user, key, value)
+        db.commit()
+        db.refresh(existing_user)
+
+        logger.info(f"User {existing_user.email} updated successfully")
+        return UserResponse(**existing_user.__dict__)
+        
+    except IntegrityError as e:
+        db.rollback()
+        if "duplicate key value violates unique constraint" in str(e.orig):
+            logger.error(f"Error updating user: {e}")
+            raise ValueError(f"Email already exists: {user_update.email}")
+        else:
+            logger.error(f"Integrity error updating user: {e}")
+            raise ValueError("An error occurred during data integrity validation.")
+    except SQLAlchemyError as e:
+        db.rollback()
+        logger.error(f"Database error updating user: {e}")
+        raise ValueError("Database error.")
+    except Exception as e:
+        logger.error(f"Unexpected error: {e}")
+        raise ValueError(f"Unexpected error: {e}")
+
+def update_photo(user_id: int, photo: str, db: Session) -> bool:
+    try:
+        user = db.query(Appuser).get(user_id)
+        user.dp = photo
+        db.commit()
+        return True
+    except Exception as e:
+        raise e
+    
+def get_userby_username(email: str,db:Session) -> Appuser:
+    user = db.query(Appuser).filter(Appuser.email == email).first()
+    return user
+
+
+def all_users(db: Session) -> list[UserResponse]:
+    try:
+        users = pg.get_all_models(Appuser, db)
+        users_resp = [
+            UserResponse(
+                **user.__dict__
+            )
+            for user in users
+        ]
+        return users_resp
+    except SQLAlchemyError as e:
+        logger.error(f"Database error retrieving all users: {e}")
+        raise ValueError("Database error.")
+    except Exception as e:
+        logger.error(f"Unexpected error retrieving all users: {e}")
+        raise ValueError("Unexpected error.")
+def delete_user(db: Session, id: int) -> bool:
+    try:
+        user = db.query(Appuser).get(id)
+        if user is None:
+            raise ValueError(f"User with id {id} not found.")
+        db.delete(user)
+        db.commit()
+        return True
+    except Exception as e:
+        raise ValueError(f"An error occurred. {e}")
+def set_delete_user(db: Session, id: int) -> bool:
+    try:
+        user = db.query(Appuser).get(id)
+        if user is None:
+            raise ValueError(f"User with id {id} not found.")
+        
+        user.status = StatusEnum.DELETED
+        db.commit()
+        return True
+        
+    except Exception as e:
+        db.rollback()  # Rollback in case of an error
+        logger.error(f"Error deleting user with id {id}: {e}")
+        raise ValueError(f"An error occurred deleting user with id {id}.")
+
+
+def users_by_role(db: Session, role: AccessRoleEnum) -> list[UserResponse]:
+    """
+    Retrieve users based on their role.
+
+    Args:
+        db (Session): Database session.
+        role (str): Role to filter users.
+
+    Returns:
+        List[UserResponse]: List of users matching the specified role.
+    """
+    users = db.query(Appuser).filter(Appuser.roles.contains([role])).order_by(desc(Appuser.id)).all()
+    users_resp = [
+        UserResponse(
+            id=user.id,
+            timestamp=user.timestamp,
+            first_name=user.first_name,
+            last_name=user.last_name,
+            email=user.email,
+            password=user.password,
+            is_active=user.is_active,
+            roles=user.roles,
+            gender=user.gender,
+            socialmedia=user.socialmedia
+        )
+        for user in users
+    ]
+    return users_resp
+
+
+def is_exist(email: EmailStr, db: Session) -> int:
+    user = db.query(Appuser).filter(Appuser.email == email).first()
+    return user.id if user else 0
+
+async def rest_password_token(email: str, db: Session) -> Appuser | None:
+    try:
+        user = db.query(Appuser).filter(Appuser.email == email).first()
+        if not user:
+            raise ValueError(f"No user with email {email}")
+        token = str(uuid.uuid4())[:8]
+        user.token = token
+        db.commit()
+        # mailer=MailerDto(
+        #         recipients=[email],
+        #         subject="Password Reset",
+        #         message=f"Your password reset token is {token}",
+        #         create_at=datetime.now(),
+        #         is_html=False
+        #     )
+        # asyncio.create_task(send_email_sendgrid(mailer))
+        # logger.info("Password reset token %s sent to %s", token, email)
+        return user
+    except Exception as e:
+        db.rollback()
+        logger.error(f"Error resetting password for {email}: {str(e)}")
+def reset_password(reset: UserReset, db: Session) -> bool:
+    try:
+        email = reset.email
+        user = db.query(Appuser).filter(
+            (Appuser.email == email) & (Appuser.token == reset.token)
+            ).first()
+        logger.info("compare %s and ",user.token, reset.token)
+        if not user:
+            raise ValueError(f"No user with email {email} or token {reset.token}")
+        user.password = encrypt_pass(reset.password)
+        db.commit()
+        return True
+    except Exception as e:
+        db.rollback()
+        logger.error(f"Error resetting password for: {str(e)}")
+        return False
+def manual_change_password(user: UserReset, db: Session) -> bool:
+    try:
+        exist_user = db.query(Appuser).filter(Appuser.email == user.email).first()
+        if not exist_user:
+            raise ValueError(f"No user with email {user.email}")
+        if not verify_password(user.password, exist_user.password):
+            raise ValueError("Incorrect username or password") from None
+        if user.new_password is None:
+            raise ValueError("New password cannot be None")
+        exist_user.password = encrypt_pass(user.new_password)
+        db.commit()
+        return True
+    except Exception as e:
+        db.rollback()
+        logger.error(f"Error resetting password for {user.email}: {str(e)}")
+        return False
+def create_address(address: AddressDto, db: Session) -> bool:
+    address = pg.add_model(Address,db, **address.model_dump())
+    return address

es_user-0.1.0/es_user/util/CONSTANTS.py

@@ -0,0 +1,18 @@
+"""Copyright 2024 Everlasting Systems and Solutions LLC (www.myeverlasting.net).
+All Rights Reserved.
+
+No part of this software or any of its contents may be reproduced, copied, modified or adapted, without the prior written consent of the author, unless otherwise indicated for stand-alone materials.
+
+For permission requests, write to the publisher at the email address below:
+office@myeverlasting.net
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+"""
+from dotenv import load_dotenv
+import os
+
+load_dotenv()
+SCHEMA = os.getenv("db_schema")
+APP = os.getenv("app_name")
+LOGO=os.getenv("logo")

es_user-0.1.0/es_user/util/enums.py

@@ -0,0 +1,30 @@
+"""Copyright 2024 Everlasting Systems and Solutions LLC (www.myeverlasting.net).
+All Rights Reserved.
+
+No part of this software or any of its contents may be reproduced, copied, modified or adapted, without the prior written consent of the author, unless otherwise indicated for stand-alone materials.
+
+For permission requests, write to the publisher at the email address below:
+office@myeverlasting.net
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+"""
+import enum
+class AccessRoleEnum(enum.Enum):
+    ADMIN = "ADMIN"
+    USER = "USER"
+    GUEST = "GUEST"
+    ACCOUNT = "ACCOUNT"
+    REFEREE = "REFEREE"
+    STAFF = "STAFF"
+class StatusEnum(enum.Enum):
+    NEW = "NEW"
+    ENROLLED = "ENROLLED"
+    ADMITTED = "ADMITTED"
+    DEBTOR = "DEBTOR"
+    DELETED = "DELETED"
+    SUSPENDED = "SUSPENDED"
+    EXPELLED = "EXPELLED"
+    PENDING = "PENDING"
+    COMPLETED = "COMPLETED"
+    FAILED = "FAILED"

es_user-0.1.0/es_user/util/service.py

@@ -0,0 +1,23 @@
+"""Copyright 2024 Everlasting Systems and Solutions LLC (www.myeverlasting.net).
+All Rights Reserved.
+
+No part of this software or any of its contents may be reproduced, copied, modified or adapted, without the prior written consent of the author, unless otherwise indicated for stand-alone materials.
+
+For permission requests, write to the publisher at the email address below:
+office@myeverlasting.net
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+"""
+import bcrypt
+
+def verify_password(plain_password: str, hashed_password: str) -> bool:
+    """
+    Verify a plain password against the hashed version.
+    """
+    # Ensure both plain_password and hashed_password are bytes
+    return bcrypt.checkpw(plain_password.encode(), hashed_password.encode())
+def encrypt_pass(plain_password: str) -> str:
+    """Hash a password for storing."""
+    salt = bcrypt.gensalt()
+    return bcrypt.hashpw(plain_password.encode(), salt).decode()

es_user-0.1.0/pyproject.toml

@@ -0,0 +1,15 @@
+[tool.poetry]
+name = "es-user"
+version = "0.1.0"
+description = "user management for ESSL apps"
+authors = ["Femi Adigun <femi.adigun@myeverlasting.net>"]
+license = "mit"
+readme = "README.md"
+
+[tool.poetry.dependencies]
+python = "^3.9"
+
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"