updated integrated with all modules

.env

+FILE_PATH=temp/_ERROR.log
+TOKEN=ticket2/
+POSTGRES_URI=postgresql://postgres:test@localhost/theater_db
+MQTT_HOST=192.168.0.220
+PORT=1883
+TABLE_NAME=ticket_details

.idea/.gitignore

+# Default ignored files
+/shelf/
+/workspace.xml

.idea/inspectionProfiles/Project_Default.xml

+<component name="InspectionProjectProfileManager">
+  <profile version="1.0">
+    <option name="myName" value="Project Default" />
+    <inspection_tool class="PyPep8NamingInspection" enabled="true" level="WEAK WARNING" enabled_by_default="true">
+      <option name="ignoredErrors">
+        <list>
+          <option value="N801" />
+        </list>
+      </option>
+    </inspection_tool>
+    <inspection_tool class="PyUnresolvedReferencesInspection" enabled="true" level="WARNING" enabled_by_default="true">
+      <option name="ignoredIdentifiers">
+        <list>
+          <option value="dict.mobile" />
+          <option value="dict.dob" />
+          <option value="dict.gender" />
+          <option value="dict.name" />
+        </list>
+      </option>
+    </inspection_tool>
+  </profile>
+</component>
\ No newline at end of file

.idea/inspectionProfiles/profiles_settings.xml

+<component name="InspectionProjectProfileManager">
+  <settings>
+    <option name="USE_PROJECT_PROFILE" value="false" />
+    <version value="1.0" />
+  </settings>
+</component>
\ No newline at end of file

.idea/misc.xml

+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectRootManager" version="2" project-jdk-name="Python 3.9 (theater_management)" project-jdk-type="Python SDK" />
+</project>
\ No newline at end of file

.idea/modules.xml

+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/.idea/theater_management.iml" filepath="$PROJECT_DIR$/.idea/theater_management.iml" />
+    </modules>
+  </component>
+</project>
\ No newline at end of file

.idea/theater_management.iml

+<?xml version="1.0" encoding="UTF-8"?>
+<module type="PYTHON_MODULE" version="4">
+  <component name="NewModuleRootManager">
+    <content url="file://$MODULE_DIR$">
+      <excludeFolder url="file://$MODULE_DIR$/venv" />
+    </content>
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>
\ No newline at end of file

.idea/vcs.xml

+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="$PROJECT_DIR$" vcs="Git" />
+  </component>
+</project>
\ No newline at end of file

app.py

+# importing libraries
+import uvicorn
+
+from scripts.logging.logger import logger
+
+if __name__ == "__main__":
+    try:
+        uvicorn.run("main:app", port=8000)
+    except Exception as e:
+        logger.error(e)
+        print("Error-", e)

conf/application.conf

+[file_path]
+path_name = temp/
\ No newline at end of file

external/bookings.json

+{
+    "header": {
+        "column0": "booking_id",
+        "column1": "mobile_no",
+        "column2": "no_of_tickets",
+        "column3": "date_of_purchase",
+        "column4": "deleted",
+        "column5": "preferred_class",
+        "column6": "seat_numbers",
+        "column7": "age"
+    },
+    "body": [
+        {
+            "booking_id": 5,
+            "mobile_no": 46356754,
+            "no_of_tickets": 1,
+            "date_of_purchase": "2023-02-14",
+            "deleted": true,
+            "preferred_class": "silver",
+            "seat_numbers": "40",
+            "age": 30
+        },
+        {
+            "booking_id": 6,
+            "mobile_no": 76788655566,
+            "no_of_tickets": 2,
+            "date_of_purchase": "2023-02-14",
+            "deleted": true,
+            "preferred_class": "gold",
+            "seat_numbers": "209,210",
+            "age": 66
+        },
+        {
+            "booking_id": 4,
+            "mobile_no": 33332233450,
+            "no_of_tickets": 5,
+            "date_of_purchase": "2023-02-14",
+            "deleted": true,
+            "preferred_class": "gold",
+            "seat_numbers": "20,21,22,23,24",
+            "age": 30
+        },
+        {
+            "booking_id": 8,
+            "mobile_no": 7766554433,
+            "no_of_tickets": 2,
+            "date_of_purchase": "2023-02-14",
+            "deleted": true,
+            "preferred_class": "silver",
+            "seat_numbers": "101,100",
+            "age": 67
+        },
+        {
+            "booking_id": 7,
+            "mobile_no": 7766554433,
+            "no_of_tickets": 2,
+            "date_of_purchase": "2023-02-14",
+            "deleted": true,
+            "preferred_class": "silver",
+            "seat_numbers": "99,98",
+            "age": 67
+        },
+        {
+            "booking_id": 1,
+            "mobile_no": 786545676,
+            "no_of_tickets": 2,
+            "date_of_purchase": "2023-02-12",
+            "deleted": true,
+            "preferred_class": "silver",
+            "seat_numbers": "10,11",
+            "age": 30
+        },
+        {
+            "booking_id": 2,
+            "mobile_no": 7878888888,
+            "no_of_tickets": 2,
+            "date_of_purchase": "2023-02-13",
+            "deleted": true,
+            "preferred_class": "gold",
+            "seat_numbers": "10,11",
+            "age": 25
+        },
+        {
+            "booking_id": 3,
+            "mobile_no": 566788998,
+            "no_of_tickets": 1,
+            "date_of_purchase": "2023-02-13",
+            "deleted": true,
+            "preferred_class": "gold",
+            "seat_numbers": "30",
+            "age": 25
+        }
+    ]
+}
\ No newline at end of file

main.py

+# importing libraries
+import uvicorn
+from fastapi import FastAPI
+from scripts.services.api_call import router
+from scripts.services.delete_ticket import delete_ticket
+
+app = FastAPI()
+app.include_router(router)
+app.include_router(delete_ticket)
+if __name__ == "__main__":
+    try:
+        uvicorn.run(app, port=8000)
+    except Exception as e:
+        print("Error-", e)

scripts/config/application_config.py

+import os
+from dotenv import load_dotenv
+from scripts.logging.logger import logger
+
+try:
+    load_dotenv()
+    token = os.getenv("TOKEN")
+    postgres_uri = os.getenv("POSTGRES_URI")
+    host = os.getenv("MQTT_HOST")
+    port_no = os.getenv("PORT")
+    table_name = os.getenv("TABLE_NAME")
+except Exception as e:
+    logger.error(e)
+    print(e)

scripts/constants/endpoints.py

+class EndPoints:
+    root = "/"
+    book_ticket = "/book ticket/"
+    delete_a_ticket = "/delete_ticket{ticket_id}"
+    cancel_all_tickets = "/cancel_all_tickets/"
+    seat_availability = "/seat_availability/"
+    get_booking_details = "/get_booking_details/"
+    show_begin = "/show_begin"
+    get_booking_details_between = "/get_booking_details_between/"
+    booking_details_json = "/booking_details_json/"
+

scripts/constants/schema.py

+from pydantic import BaseModel
+
+
+# Model for fetching details from user
+class ticket_booking(BaseModel):
+    mobile_no: int
+    preferred_class: str
+    no_of_tickets: int
+    seat_numbers: str
+    age: int
+

scripts/core/handlers/api_functions.py

+import json
+from datetime import datetime
+import pandas as pd
+import paho.mqtt.client as mqtt
+from fastapi import HTTPException
+from scripts.config.application_config import token, host
+from scripts.core.handlers.avail_seats_redis import check_seat_avail
+from scripts.core.handlers.format_data_from_db import clean_record
+from scripts.database.RedisDB.db_connection import conn
+from scripts.database.postgresql.db_connection import db_connect
+from scripts.database.postgresql.model import BookingDetails
+from scripts.logging.logger import logger
+
+
+class Tickets:
+    def __init__(self):
+        self.session = db_connect()
+        self.client = mqtt.Client()
+        self.client.connect(host, 1883, 60)
+        self.booked_list = []
+
+    def insert_data_into_db(self, details):
+        # add new booking details
+        try:
+            # Check if the data entered
+            if 5 < details.no_of_tickets or details.no_of_tickets <= 0:
+                raise HTTPException(status_code=400, detail="Invalid value for no. of tickets or"
+                                                            " Can book only 5 tickets at a time.")
+            if details.preferred_class not in ["gold", "silver"]:
+                raise HTTPException(status_code=400, detail="Invalid class type")
+            seats = details.seat_numbers.split(",")
+            integer_list = [int(item) for item in seats]
+            if len(integer_list) != details.no_of_tickets:
+                raise HTTPException(status_code=400, detail="Number of seat numbers must match the number of tickets")
+
+            for seat_ in integer_list:
+                if seat_ not in self.booked_list:
+                    if not check_seat_avail(conn, details.preferred_class, int(seat_)):
+                        self.booked_list.append(seat_)
+            if self.booked_list:
+                raise HTTPException(status_code=400,
+                                    detail=f"Seat number that are already booked are : {self.booked_list} \n"
+                                           f"seat number you are going to book  are {integer_list}")
+
+            payload = {details.preferred_class: integer_list}
+            self.client.publish(token, json.dumps(payload))
+            new_booking = BookingDetails(mobile_no=details.mobile_no,
+                                         preferred_class=details.preferred_class,
+                                         no_of_tickets=details.no_of_tickets,
+                                         seat_numbers=details.seat_numbers,
+                                         age=details.age)
+
+            self.session.add(new_booking)
+            self.session.commit()
+            return {"message": "Ticket booking successful"}
+        except Exception as e:
+            return e
+
+    def cancel_tickets(self):
+        try:
+            query = self.session.query(BookingDetails).update({BookingDetails.deleted: True})
+            # Commit the changes to the database
+            self.session.commit()
+            if query is not None:
+                # Publish the Message
+                topic = "ticket2/cancel_all"
+                message = "Show Cancelled"
+                self.client.publish(topic, message)
+        except Exception as e:
+            logger.error(e)
+
+    def delete_row(self, booking_id):
+        try:
+            # Soft delete a row in the ticket_details table
+            ticket = self.session.query(BookingDetails).filter(BookingDetails.booking_id == booking_id,
+                                                               BookingDetails.deleted == False).first()
+            if ticket is not None:
+                ticket.deleted = True
+                self.session.commit()
+                no_seats = ticket.seat_numbers
+                data_of_list = no_seats.split(",")
+                integer_list = [int(item) for item in data_of_list]
+                data = {ticket.preferred_class: integer_list}
+                self.client.publish("ticket2/delete", json.dumps(data))
+                return data
+            else:
+                print(f"Ticket with id {booking_id} is not exist")
+                logger.error(f"Ticket with id {booking_id} is not exist")
+                return {"message": f"ticket with id {booking_id} not exist", "status": "Ticket not exist",
+                        "data": booking_id}
+
+        except Exception as e:
+            logger.error(e)
+
+    def get_details(self):
+        try:
+            records = self.session.query(BookingDetails).all()
+            cleaned_data_dict = clean_record(records)
+            # Use pandas to convert the list of dictionaries to a DataFrame
+            df = pd.DataFrame(cleaned_data_dict)
+            # Creating excel writer object
+            writer = pd.ExcelWriter('external/booking_details.xlsx')
+            # Write dataframe to excel
+            df.to_excel(writer, index=False)
+            # save the Excel
+            writer.save()
+        except Exception as e:
+            logger.error(e)
+
+    def get_details_between(self, from_date, to_date):
+        try:
+            records = self.session.query(BookingDetails).filter(
+                BookingDetails.date_of_purchase.between(datetime.strptime(from_date, "%Y-%m-%d").date(),
+                                                        datetime.strptime(to_date, "%Y-%m-%d").date())).all()
+            cleaned_data_dict = clean_record(records)
+            # Use pandas to convert the list of dictionaries to a DataFrame
+            df = pd.DataFrame(cleaned_data_dict)
+            # Use pandas to save the DataFrame to an Excel file
+            df.to_excel(f'external/booking_from_{from_date}_to_{to_date}_.xlsx', index=False)
+        except Exception as e:
+            logger.error(e)
+
+    @staticmethod
+    def json_data(dataframe):
+        try:
+            dataframe["date_of_purchase"] = dataframe["date_of_purchase"].dt.strftime('%Y-%m-%d')
+            keys = [f"column{i}" for i in range(len(dataframe.columns))]
+            header_dict = {'header': dict(zip(keys, dataframe.columns))}
+            data = {"body": dataframe.to_dict(orient='records')}
+            json_dict = {**header_dict, **data}
+            with open("external/bookings.json", "w") as json_file:
+                json.dump(json_dict, json_file, indent=4)
+            return json_dict
+        except Exception as e:
+            logger.exception(e)
+            print("Reading error-", e)

scripts/core/handlers/avail_seats_redis.py

+import pickle
+
+
+# check for the seat availability
+def check_seat_avail(connection, ticket_class, seats_needed):
+    try:
+        class_lists = {
+            "gold": pickle.loads(connection.get("gold")),
+            "silver": pickle.loads(connection.get("silver"))
+        }
+        # get the availability of seat
+        if ticket_class not in class_lists:
+            return None
+        flag = 0
+        for seats in class_lists[ticket_class]:
+            if seats_needed in seats:
+                flag += 1
+                return True
+        if flag == 0:
+            return False
+    except Exception as e:
+        print(e)
+
+

scripts/core/handlers/create_redis_db.py

+# create redis db
+import pickle
+
+
+def redis_db_create(connection, ticket_class, seats, total_count):
+    try:
+        mapper_ticket_class = {
+            "gold": lambda count: connection.set("gold_available_seats", count),
+            "silver": lambda count: connection.set("silver_available_seats", count)
+        }
+
+        # if the class is not present
+        if ticket_class not in mapper_ticket_class:
+            return None
+
+        # getting the class from the mapper
+        mapper_ticket_class[ticket_class](total_count)
+
+        list_ = []
+        # appending to the list for creating the redis db
+        for row in range(1, total_count, seats):
+            list_.append([seat for seat in range(row, row + seats)])
+
+        return True if connection.set(ticket_class, pickle.dumps(list_)) else False
+    except Exception as e:
+        print(e)

scripts/core/handlers/format_data_from_db.py

+def clean_record(records):
+    dict_records = [record.__dict__ for record in records]
+    # Remove any keys from the dictionaries that start with an underscore
+    dict_records_clean = [
+        {
+            key: values for key, values in record.items() if not key.startswith('_')
+        }
+        for record in dict_records
+    ]
+    return dict_records_clean

scripts/core/handlers/get_all_seats.py

+# check if class seats are available
+import pickle
+
+
+def data_decode(val):
+    # decode the val to integers
+    if int(val.decode('UTF-8')):
+        return True
+    else:
+        return False
+
+
+def create_json_view(connection, ticket_class):
+    mapper_ticket_class = {
+        "gold": pickle.loads(connection.get("gold")),
+        "silver": pickle.loads(connection.get("silver"))
+    }
+
+    class_list = mapper_ticket_class[ticket_class]
+    data = {"message": "Seat Availability"}
+    # create the json for the user to view
+    for i, row in enumerate(class_list):
+        data["Row {}".format(i + 1)] = ", ".join(map(str, row))
+    return data
+
+
+# check if seats are available if then return seats else then return class that's available or return houseful
+def seat_availability(connection, ticket_class):
+    try:
+        # counter for the checking if one class is full then get the other class
+        counter = None
+        class_avail = {
+            "gold": connection.get("gold_available_seats"),
+            "silver": connection.get("silver_available_seats")
+        }
+
+        # decode the data and the seat availability
+        for key, val in class_avail.items():
+            check_status = data_decode(val)
+            if key == ticket_class and check_status:
+                return create_json_view(connection, ticket_class)
+            elif key is not ticket_class and check_status:
+                counter = key
+                continue
+        if counter is not None:
+            return {"message": "Seat Availability", "Status": "Not Available", counter: "Available"}
+        else:
+            return {"HouseFull"}
+    except Exception as e:
+        print(e)

scripts/database/RedisDB/db_connection.py

+import redis
+
+# gold seats db on redis
+conn = redis.Redis('127.0.0.1', db=3)

scripts/database/postgresql/db_connection.py

+from sqlalchemy import create_engine
+from sqlalchemy.orm import sessionmaker
+from scripts.config.application_config import postgres_uri
+from scripts.database.postgresql.model import Base
+from scripts.logging.logger import logger
+
+
+def db_connect():
+    try:
+        engine = create_engine(postgres_uri)
+        sessions = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+        Base.metadata.create_all(engine)
+        session = sessions()
+        return session
+    except Exception as e:
+        logger.error(e)

scripts/database/postgresql/model.py

+from datetime import date
+from sqlalchemy import Column, Integer, String, Date, Boolean, BIGINT
+from sqlalchemy.orm import declarative_base
+
+from scripts.config.application_config import table_name
+
+Base = declarative_base()
+
+
+# create BookingDetails class
+class BookingDetails(Base):
+    __tablename__ = table_name
+    booking_id = Column(Integer, primary_key=True)
+    mobile_no = Column(BIGINT)
+    preferred_class = Column(String)
+    no_of_tickets = Column(Integer)
+    seat_numbers = Column(String)
+    date_of_purchase = Column(Date, default=date.today())
+    age = Column(Integer)
+    deleted = Column(Boolean, default=False)

scripts/logging/logger.py

+import logging
+import os
+from logging.handlers import RotatingFileHandler
+
+
+def get_logger():
+    """
+     Creates a rotating log
+     """
+    __logger__ = logging.getLogger('')
+    __logger__.setLevel("ERROR")
+    log_formatter = '%(asctime)s - %(levelname)-6s - [%(threadName)5s:%(funcName)5s():%(lineno)s] - %(message)s'
+    time_format = "%Y-%m-%d %H:%M:%S"
+    formatter = logging.Formatter(log_formatter, time_format)
+    log_files = os.path.join("temp/_ERROR.log")
+    temp_handler = RotatingFileHandler(log_files, maxBytes=100000000, backupCount=5)
+    temp_handler.setFormatter(formatter)
+
+    __logger__.addHandler(temp_handler)
+
+    return __logger__
+
+
+logger = get_logger()

scripts/services/api_call.py

+# importing libraries
+from fastapi import APIRouter, UploadFile
+from scripts.constants.endpoints import EndPoints
+from scripts.constants.schema import ticket_booking
+from scripts.core.handlers.api_functions import Tickets
+from scripts.core.handlers.create_redis_db import redis_db_create
+from scripts.core.handlers.get_all_seats import seat_availability
+from scripts.database.RedisDB.db_connection import conn
+from scripts.logging.logger import logger
+import pandas as pd
+
+# Create FastAPI instance
+router = APIRouter()
+
+
+# Root
+@router.get(EndPoints.root)
+async def root():
+    return {"Message": "It's Working!"}
+
+
+@router.get(EndPoints.seat_availability)
+def check_seats(ticket_class: str):
+    message = seat_availability(conn, ticket_class)
+    return message
+
+
+@router.post(EndPoints.book_ticket, tags=["Ticket Booking"])
+async def book_ticket(details: ticket_booking):
+    try:
+        return Tickets().insert_data_into_db(details)
+    except Exception as e:
+        logger.error(e)
+        print("error ", e)
+
+
+@router.get(EndPoints.get_booking_details, tags=["get booking details"])
+def get_booking_details():
+    try:
+        Tickets().get_details()
+        return {"data": "list all the data"}
+    except Exception as e:
+        logger.error(e)
+        print(e)
+
+
+@router.get(EndPoints.get_booking_details_between, tags=["get booking details between"])
+def get_booking_details_between(from_date: str, to_date: str):
+    Tickets().get_details_between(from_date, to_date)
+    return {"Message": f"Data stored on file from {from_date} to {to_date}."}
+
+
+@router.get(EndPoints.show_begin, tags=["show_begin"])
+def generate_seats():
+    try:
+        redis_db_create(conn, "gold", 30, 300)
+        redis_db_create(conn, "silver", 25, 125)
+        return "booking started"
+    except Exception as e:
+        logger.error(e)
+        print(e)
+
+
+@router.post(EndPoints.booking_details_json, tags=["Create Json File"])
+async def booking_details_json_format(file: UploadFile):
+    try:
+        excel_file = pd.read_excel(await file.read())
+        message = Tickets().json_data(excel_file)
+        return message
+    except Exception as e:
+        logger.error(e)

scripts/services/delete_ticket.py

+from fastapi import APIRouter
+from scripts.constants.endpoints import EndPoints
+from scripts.core.handlers.api_functions import Tickets
+from scripts.logging.logger import logger
+
+delete_ticket = APIRouter()
+
+
+@delete_ticket.post(EndPoints.delete_a_ticket, tags=["delete a ticket"])
+def delete_tickets(tid: int):
+    try:
+        res = Tickets().delete_row(tid)
+        return res
+    except Exception as e:
+        logger.error(e)
+
+
+@delete_ticket.get(EndPoints.cancel_all_tickets, tags=["cancel show"])
+async def cancel_all_tickets():
+    Tickets().cancel_tickets()
+    return {"Message": "Cancelled all Tickets"}