Upload 16 files

Dockerfile

@@ -0,0 +1,21 @@
+FROM python:3.9-slim
+
+# Set working directory
+WORKDIR /app
+
+# Copy requirements file and install dependencies
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy .env file into the container
+COPY .env .
+
+# Copy application code
+COPY app/ app/
+COPY run.py .
+
+# Expose the port the app runs on
+EXPOSE 8000
+
+# Command to run the application
+CMD ["python3", "run.py"]

app/database/database.py

@@ -0,0 +1,63 @@
+from sqlalchemy import create_engine
+from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy.orm import sessionmaker
+import os
+from dotenv import load_dotenv
+import logging
+import urllib.parse
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Load environment variables
+load_dotenv()
+
+# Get database credentials from environment variables
+DB_USER = os.getenv("DB_USER", "dev_cbs_admin")
+DB_PASSWORD = os.getenv("DB_PASSWORD", "password")
+DB_HOST = os.getenv("DB_HOST", "13.126.242.31")
+DB_PORT = os.getenv("DB_PORT", "5432")
+DB_NAME = os.getenv("DB_NAME", "vst")
+
+# URL encode the password to handle special characters like @
+encoded_password = urllib.parse.quote_plus(DB_PASSWORD)
+
+# Log the connection parameters (without password)
+logger.info(f"Attempting to connect to PostgreSQL database at {DB_HOST}:{DB_PORT}/{DB_NAME} as {DB_USER}")
+
+# Create database URL for PostgreSQL with encoded password
+SQLALCHEMY_DATABASE_URL = f"postgresql://{DB_USER}:{encoded_password}@{DB_HOST}:{DB_PORT}/{DB_NAME}"
+# Log the URL with password masked
+masked_url = SQLALCHEMY_DATABASE_URL.replace(encoded_password, "****")
+logger.info(f"Connection URL: {masked_url}")
+
+try:
+    # Create engine
+    engine = create_engine(SQLALCHEMY_DATABASE_URL)
+    
+    # Test connection
+    with engine.connect() as conn:
+        logger.info("Database connection successful")
+except Exception as e:
+    logger.error(f"Database connection error: {e}")
+    # Create a SQLite engine as fallback for development/testing
+    logger.info("Using SQLite as fallback database")
+    SQLALCHEMY_DATABASE_URL = "sqlite:///./visitor_management.db"
+    engine = create_engine(
+        SQLALCHEMY_DATABASE_URL, connect_args={"check_same_thread": False}
+    )
+
+# Create session
+SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+
+# Create base class
+Base = declarative_base()
+
+# Dependency to get DB session
+def get_db():
+    db = SessionLocal()
+    try:
+        yield db
+    finally:
+        db.close()

app/main.py

@@ -0,0 +1,34 @@
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+
+from app.database.database import engine
+from app.models.models import Base
+from app.routers import visitor_log, meeting_status, person_to_meet
+
+# Create database tables
+Base.metadata.create_all(bind=engine)
+
+# Initialize FastAPI app
+app = FastAPI(
+    title="Visitor Management System API",
+    description="API for managing visitor logs and meeting statuses",
+    version="1.0.0"
+)
+
+# Add CORS middleware
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],  # In production, replace with specific origins
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Include routers
+app.include_router(visitor_log.router)
+app.include_router(meeting_status.router)
+app.include_router(person_to_meet.router)
+
+@app.get("/")
+def read_root():
+    return {"message": "Welcome to Visitor Management System API"}

app/models/models.py

@@ -0,0 +1,40 @@
+from sqlalchemy import Column, Integer, String, DateTime, ForeignKey
+from sqlalchemy.orm import relationship
+from app.database.database import Base
+
+class VisitorLog(Base):
+    __tablename__ = "visitor_log"
+    
+    sl_no = Column(Integer, primary_key=True, index=True, autoincrement=True)
+    full_name = Column(String(255), nullable=False)
+    email_address = Column(String(255), nullable=False)
+    phone_number = Column(String(20), nullable=False)
+    company_name = Column(String(255), nullable=True)
+    qid_id_number = Column(String(50), nullable=True)
+    purpose_of_visit = Column(String(500), nullable=False)
+    person_to_meet = Column(String(255), nullable=False)
+    preferred_datetime = Column(DateTime, nullable=False)
+    reference_number = Column(String(50), unique=True, nullable=False, index=True)
+    
+    # Relationship with MeetingStatus
+    meeting_status = relationship("MeetingStatus", back_populates="visitor_log")
+
+class MeetingStatus(Base):
+    __tablename__ = "meeting_status"
+    
+    sl_no = Column(Integer, primary_key=True, index=True, autoincrement=True)
+    reference_number = Column(String(50), ForeignKey("visitor_log.reference_number"), nullable=False, unique=True)
+    status = Column(String(50), nullable=False)
+    email_send = Column(String(10), nullable=True)  # Assuming this is a Yes/No or similar status
+    
+    # Relationship with VisitorLog
+    visitor_log = relationship("VisitorLog", back_populates="meeting_status")
+
+class PersonToMeet(Base):
+    __tablename__ = "person_to_meet"
+    
+    id = Column(Integer, primary_key=True, index=True, autoincrement=True)
+    name = Column(String(255), nullable=False)
+    phone_number = Column(String(20), nullable=False, unique=True)
+    department = Column(String(255), nullable=False)
+    email_id = Column(String(255), nullable=False)

app/routers/meeting_status.py

@@ -0,0 +1,74 @@
+from fastapi import APIRouter, Depends, HTTPException, status
+from sqlalchemy.orm import Session
+from typing import List
+
+from app.database.database import get_db
+from app.models.models import MeetingStatus, VisitorLog
+from app.schemas.schemas import MeetingStatusCreate, MeetingStatusUpdate, MeetingStatusResponse
+
+router = APIRouter(
+    prefix="/meeting-status",
+    tags=["meeting-status"]
+)
+
+# Create meeting status
+@router.post("/", response_model=MeetingStatusResponse, status_code=status.HTTP_201_CREATED)
+def create_meeting_status(meeting_status: MeetingStatusCreate, db: Session = Depends(get_db)):
+    # Check if visitor log exists
+    visitor_log = db.query(VisitorLog).filter(VisitorLog.reference_number == meeting_status.reference_number).first()
+    if not visitor_log:
+        raise HTTPException(status_code=404, detail="Visitor log not found")
+    
+    # Check if meeting status already exists
+    existing_status = db.query(MeetingStatus).filter(MeetingStatus.reference_number == meeting_status.reference_number).first()
+    if existing_status:
+        raise HTTPException(status_code=400, detail="Meeting status already exists for this reference number")
+    
+    db_meeting_status = MeetingStatus(
+        reference_number=meeting_status.reference_number,
+        status=meeting_status.status,
+        email_send=meeting_status.email_send
+    )
+    db.add(db_meeting_status)
+    db.commit()
+    db.refresh(db_meeting_status)
+    return db_meeting_status
+
+# Get all meeting statuses
+@router.get("/", response_model=List[MeetingStatusResponse])
+def get_all_meeting_statuses(skip: int = 0, limit: int = 100, db: Session = Depends(get_db)):
+    return db.query(MeetingStatus).offset(skip).limit(limit).all()
+
+# Get meeting status by reference number
+@router.get("/{reference_number}", response_model=MeetingStatusResponse)
+def get_meeting_status(reference_number: str, db: Session = Depends(get_db)):
+    db_meeting_status = db.query(MeetingStatus).filter(MeetingStatus.reference_number == reference_number).first()
+    if db_meeting_status is None:
+        raise HTTPException(status_code=404, detail="Meeting status not found")
+    return db_meeting_status
+
+# Update meeting status
+@router.put("/{reference_number}", response_model=MeetingStatusResponse)
+def update_meeting_status(reference_number: str, meeting_status: MeetingStatusUpdate, db: Session = Depends(get_db)):
+    db_meeting_status = db.query(MeetingStatus).filter(MeetingStatus.reference_number == reference_number).first()
+    if db_meeting_status is None:
+        raise HTTPException(status_code=404, detail="Meeting status not found")
+    
+    # Update meeting status fields
+    for key, value in meeting_status.dict().items():
+        setattr(db_meeting_status, key, value)
+    
+    db.commit()
+    db.refresh(db_meeting_status)
+    return db_meeting_status
+
+# Delete meeting status
+@router.delete("/{reference_number}", status_code=status.HTTP_204_NO_CONTENT)
+def delete_meeting_status(reference_number: str, db: Session = Depends(get_db)):
+    db_meeting_status = db.query(MeetingStatus).filter(MeetingStatus.reference_number == reference_number).first()
+    if db_meeting_status is None:
+        raise HTTPException(status_code=404, detail="Meeting status not found")
+    
+    db.delete(db_meeting_status)
+    db.commit()
+    return None

app/routers/person_to_meet.py

@@ -0,0 +1,65 @@
+from fastapi import APIRouter, Depends, HTTPException, status
+from sqlalchemy.orm import Session
+from typing import List
+
+from app.database.database import get_db
+from app.models.models import PersonToMeet
+from app.schemas.schemas import PersonToMeetCreate, PersonToMeetUpdate, PersonToMeetResponse
+
+router = APIRouter(
+    prefix="/person-to-meet",
+    tags=["person-to-meet"]
+)
+
+# Create person to meet
+@router.post("/", response_model=PersonToMeetResponse, status_code=status.HTTP_201_CREATED)
+def create_person_to_meet(person: PersonToMeetCreate, db: Session = Depends(get_db)):
+    db_person = PersonToMeet(
+        name=person.name,
+        phone_number=person.phone_number,
+        department=person.department,
+        email_id=person.email_id
+    )
+    db.add(db_person)
+    db.commit()
+    db.refresh(db_person)
+    return db_person
+
+# Get all persons to meet
+@router.get("/", response_model=List[PersonToMeetResponse])
+def get_all_persons_to_meet(skip: int = 0, limit: int = 100, db: Session = Depends(get_db)):
+    return db.query(PersonToMeet).offset(skip).limit(limit).all()
+
+# Get person to meet by ID
+@router.get("/{person_id}", response_model=PersonToMeetResponse)
+def get_person_to_meet(person_id: int, db: Session = Depends(get_db)):
+    db_person = db.query(PersonToMeet).filter(PersonToMeet.id == person_id).first()
+    if db_person is None:
+        raise HTTPException(status_code=404, detail="Person to meet not found")
+    return db_person
+
+# Update person to meet
+@router.put("/{person_id}", response_model=PersonToMeetResponse)
+def update_person_to_meet(person_id: int, person: PersonToMeetUpdate, db: Session = Depends(get_db)):
+    db_person = db.query(PersonToMeet).filter(PersonToMeet.id == person_id).first()
+    if db_person is None:
+        raise HTTPException(status_code=404, detail="Person to meet not found")
+    
+    # Update person fields
+    for key, value in person.dict().items():
+        setattr(db_person, key, value)
+    
+    db.commit()
+    db.refresh(db_person)
+    return db_person
+
+# Delete person to meet
+@router.delete("/{person_id}", status_code=status.HTTP_204_NO_CONTENT)
+def delete_person_to_meet(person_id: int, db: Session = Depends(get_db)):
+    db_person = db.query(PersonToMeet).filter(PersonToMeet.id == person_id).first()
+    if db_person is None:
+        raise HTTPException(status_code=404, detail="Person to meet not found")
+    
+    db.delete(db_person)
+    db.commit()
+    return None

app/routers/visitor_log.py

@@ -0,0 +1,76 @@
+from fastapi import APIRouter, Depends, HTTPException, status
+from sqlalchemy.orm import Session
+from typing import List
+import uuid
+
+from app.database.database import get_db
+from app.models.models import VisitorLog
+from app.schemas.schemas import VisitorLogCreate, VisitorLogResponse, VisitorWithStatusResponse
+
+router = APIRouter(
+    prefix="/visitor-log",
+    tags=["visitor-log"]
+)
+
+# Generate unique reference number
+def generate_reference_number():
+    return f"VST-{uuid.uuid4().hex[:8].upper()}"
+
+# Create visitor log
+@router.post("/", response_model=VisitorLogResponse, status_code=status.HTTP_201_CREATED)
+def create_visitor_log(visitor: VisitorLogCreate, db: Session = Depends(get_db)):
+    reference_number = generate_reference_number()
+    db_visitor = VisitorLog(
+        full_name=visitor.full_name,
+        email_address=visitor.email_address,
+        phone_number=visitor.phone_number,
+        company_name=visitor.company_name,
+        qid_id_number=visitor.qid_id_number,
+        purpose_of_visit=visitor.purpose_of_visit,
+        person_to_meet=visitor.person_to_meet,
+        preferred_datetime=visitor.preferred_datetime,
+        reference_number=reference_number
+    )
+    db.add(db_visitor)
+    db.commit()
+    db.refresh(db_visitor)
+    return db_visitor
+
+# Get all visitor logs
+@router.get("/", response_model=List[VisitorLogResponse])
+def get_all_visitor_logs(skip: int = 0, limit: int = 100, db: Session = Depends(get_db)):
+    return db.query(VisitorLog).offset(skip).limit(limit).all()
+
+# Get visitor log by reference number
+@router.get("/{reference_number}", response_model=VisitorWithStatusResponse)
+def get_visitor_log(reference_number: str, db: Session = Depends(get_db)):
+    db_visitor = db.query(VisitorLog).filter(VisitorLog.reference_number == reference_number).first()
+    if db_visitor is None:
+        raise HTTPException(status_code=404, detail="Visitor log not found")
+    return db_visitor
+
+# Update visitor log
+@router.put("/{reference_number}", response_model=VisitorLogResponse)
+def update_visitor_log(reference_number: str, visitor: VisitorLogCreate, db: Session = Depends(get_db)):
+    db_visitor = db.query(VisitorLog).filter(VisitorLog.reference_number == reference_number).first()
+    if db_visitor is None:
+        raise HTTPException(status_code=404, detail="Visitor log not found")
+    
+    # Update visitor log fields
+    for key, value in visitor.dict().items():
+        setattr(db_visitor, key, value)
+    
+    db.commit()
+    db.refresh(db_visitor)
+    return db_visitor
+
+# Delete visitor log
+@router.delete("/{reference_number}", status_code=status.HTTP_204_NO_CONTENT)
+def delete_visitor_log(reference_number: str, db: Session = Depends(get_db)):
+    db_visitor = db.query(VisitorLog).filter(VisitorLog.reference_number == reference_number).first()
+    if db_visitor is None:
+        raise HTTPException(status_code=404, detail="Visitor log not found")
+    
+    db.delete(db_visitor)
+    db.commit()
+    return None

app/schemas/schemas.py

@@ -0,0 +1,68 @@
+from pydantic import BaseModel, EmailStr, Field
+from datetime import datetime
+from typing import Optional
+
+# VisitorLog Schemas
+class VisitorLogBase(BaseModel):
+    full_name: str
+    email_address: EmailStr
+    phone_number: str
+    company_name: Optional[str] = None
+    qid_id_number: Optional[str] = None
+    purpose_of_visit: str
+    person_to_meet: str
+    preferred_datetime: datetime
+    
+class VisitorLogCreate(VisitorLogBase):
+    pass
+
+class VisitorLogResponse(VisitorLogBase):
+    sl_no: int
+    reference_number: str
+    
+    class Config:
+        from_attributes = True  # Updated from orm_mode
+
+# MeetingStatus Schemas
+class MeetingStatusBase(BaseModel):
+    status: str
+    email_send: Optional[str] = None
+    
+class MeetingStatusCreate(MeetingStatusBase):
+    reference_number: str
+    
+class MeetingStatusUpdate(MeetingStatusBase):
+    pass
+    
+class MeetingStatusResponse(MeetingStatusBase):
+    sl_no: int
+    reference_number: str
+    
+    class Config:
+        from_attributes = True  # Updated from orm_mode
+
+# Combined Response Schema
+class VisitorWithStatusResponse(VisitorLogResponse):
+    meeting_status: Optional[MeetingStatusResponse] = None
+    
+    class Config:
+        from_attributes = True  # Updated from orm_mode
+
+# PersonToMeet Schemas
+class PersonToMeetBase(BaseModel):
+    name: str
+    phone_number: str
+    department: str
+    email_id: EmailStr
+
+class PersonToMeetCreate(PersonToMeetBase):
+    pass
+
+class PersonToMeetUpdate(PersonToMeetBase):
+    pass
+
+class PersonToMeetResponse(PersonToMeetBase):
+    id: int
+    
+    class Config:
+        from_attributes = True

run.py

@@ -0,0 +1,4 @@
+import uvicorn
+
+if __name__ == "__main__":
+    uvicorn.run("app.main:app", host="0.0.0.0", port=8000, reload=True)