integrated

.env

+FILE_PATH=temp/logging_log_ERROR.log
+TOKEN=ticket2/
+DELETE_TOPIC=ticket2/delete
+CANCEL_TOPIC=ticket2/cancel_all
+POSTGRES_URI=postgresql://postgres:test@localhost/ticket
+MQTT_HOST=192.168.0.220
+PORT=1883
+TABLE_NAME=ticket_details

.idea/.gitignore

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

.idea/Ticket-publish.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/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>
+  </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 (Ticket-publish)" 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/Ticket-publish.iml" filepath="$PROJECT_DIR$/.idea/Ticket-publish.iml" />
+    </modules>
+  </component>
+</project>
\ No newline at end of file

.idea/sonarlint/issuestore/8/2/82b5a4e003bc46f722987f102bd24b2052704617

+
+rpython:S3776ö"TRefactor this function to reduce its Cognitive Complexity from 16 to the 15 allowed.(Ž‹ìõüÿÿÿÿ

+mpython:S3776¶"TRefactor this function to reduce its Cognitive Complexity from 40 to the 15 allowed.(ôÒŽ×
+Mpython:S1135Ý"4Complete the task associated to this "TODO" comment.(Ͷ»û
+rpython:S3776š	"TRefactor this function to reduce its Cognitive Complexity from 18 to the 15 allowed.(¦Ã§Öûÿÿÿÿ

+Upython:S5754µ	"<Specify an exception class to catch or reraise the exception(ˆÊÉ·
+rpython:S3776Þ	"TRefactor this function to reduce its Cognitive Complexity from 27 to the 15 allowed.(³»ó‘ýÿÿÿÿ

+Rpython:S1135¶
+"4Complete the task associated to this "TODO" comment.( £ˆ”ýÿÿÿÿ

+Apython:S108Ç")Either remove or fill this block of code.(ã‘Û¾
+rpython:S3776Û"TRefactor this function to reduce its Cognitive Complexity from 35 to the 15 allowed.(ϭбþÿÿÿÿ

+rpython:S3776Ù"TRefactor this function to reduce its Cognitive Complexity from 58 to the 15 allowed.(÷­öŠýÿÿÿÿ

+rpython:S3776Ù"TRefactor this function to reduce its Cognitive Complexity from 26 to the 15 allowed.(¾àÿæøÿÿÿÿ

+Epython:S1481À"'Remove the unused local variable "obj".(䩵ñùÿÿÿÿ

+rpython:S3776Ñ"TRefactor this function to reduce its Cognitive Complexity from 28 to the 15 allowed.(˜­óîúÿÿÿÿ

+Mpython:S1135´"4Complete the task associated to this "TODO" comment.(­ß…Æ
+mpython:S3776®"TRefactor this function to reduce its Cognitive Complexity from 36 to the 15 allowed.(ÖÞ•Ñ
+mpython:S3776¿ "TRefactor this function to reduce its Cognitive Complexity from 25 to the 15 allowed.(ù¶ÎÙ
+Upython:S5754³!"<Specify an exception class to catch or reraise the exception(ˆÊÉ·
+Upython:S5754¿#"<Specify an exception class to catch or reraise the exception(ˆÊÉ·
+Spython:S2836Ž$"5Add a "break" statement or remove this "else" clause.(³£œ‰øÿÿÿÿ

\ No newline at end of file

.idea/sonarlint/issuestore/d/f/df30e052d0bbb84a453d3c6584c1f74ac22a2ed6

+
+Hpython:S1066"/Merge this if statement with the enclosing one.(
+kpython:S1226
"MIntroduce a new variable or use its initial value before reassigning 'dict_'.(

\ No newline at end of file

.idea/sonarlint/issuestore/index.pb

+
+`
+0venv/Lib/site-packages/sqlalchemy/orm/session.py,8\2\82b5a4e003bc46f722987f102bd24b2052704617
+a
+1venv/Lib/site-packages/sqlalchemy/orm/decl_api.py,d\f\df30e052d0bbb84a453d3c6584c1f74ac22a2ed6
\ 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

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

conf/app.conf

+[log_file_path1]
+file_name=scripts/external/logging_log
+[excel_path]
+file_path=scripts/external/booking_details.xlsx
\ No newline at end of file

main.py

+import uvicorn
+from fastapi import FastAPI
+from scripts.logging.logging import logger
+from scripts.services.delete_ticket import delete_ticket
+from scripts.services.publish import router
+
+app = FastAPI()
+app.include_router(router)
+app.include_router(delete_ticket)
+if __name__ == "__main__":
+    try:
+        uvicorn.run(app, port=8765)
+    except Exception as e:
+        logger.error(e)
+        print(e)

scripts/config/application_config.py

+import configparser
+import os
+from dotenv import load_dotenv
+
+try:
+    config = configparser.ConfigParser()
+    config.read(r"conf\app.conf")
+    # logging file path
+    file_name = config.get("log_file_path1", "file_name")
+    # Excel file path
+    file_path = config.get("excel_path", "file_path")
+except configparser.NoOptionError as e:
+    print(f"could not find conf file {e}")
+
+try:
+    load_dotenv()
+    token = os.getenv("TOKEN")
+    del_topic = os.getenv("DELETE_TOPIC")
+    can_topic = os.getenv("CANCEL_TOPIC")
+    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:
+    print(e)

scripts/config/db_connect.py

+from sqlalchemy import create_engine
+from sqlalchemy.orm import sessionmaker
+from scripts.database.model import Base
+from scripts.logging.logging import logger
+
+
+def db_connect():
+    try:
+        engine = create_engine("postgresql://postgres:123@localhost/ticket")
+        sessions = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+        Base.metadata.create_all(engine)
+        session = sessions()
+        return session
+    except Exception as e:
+        logger.error(e)
+        print(e)

scripts/config/redis_connection.py

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

scripts/constants/end_points.py

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

scripts/core/handlers/avail_seat_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/book_ticket.py

+import json
+import pandas as pd
+from fastapi import HTTPException
+import paho.mqtt.client as mqtt
+from scripts.config.application_config import token, host, file_path
+from scripts.config.db_connect import db_connect
+from scripts.config.redis_connection import conn
+from scripts.core.handlers.avail_seat_redis import check_seat_avail
+from scripts.core.handlers.format_data_from_db import clean_record
+from scripts.database.model import Ticket
+from scripts.logging.logging import logger
+
+
+class BookTicket:
+    @staticmethod
+    def book_ticket(ticket):
+        try:
+            client = mqtt.Client()
+            client.connect(host, 1883, 60)
+            booked_list = []
+
+            # Check if the data entered
+            if ticket.no_of_tickets > 5:
+                return HTTPException(status_code=400, detail="Can book only 5 tickets at a time.")
+            if ticket.preferred_class not in ["gold", "silver"]:
+                return HTTPException(status_code=400, detail="Invalid class type")
+            seats = ticket.seat_no.split(",")
+            integer_list = [int(item) for item in seats]
+            if len(integer_list) != ticket.no_of_tickets:
+                return HTTPException(status_code=400,
+                                     detail="Number of seat numbers must match the number of tickets")
+
+            for seat_ in integer_list:
+                if seat_ not in booked_list:
+                    if not check_seat_avail(conn, ticket.preferred_class, int(seat_)):
+                        booked_list.append(seat_)
+            if booked_list:
+                return HTTPException(status_code=400,
+                                     detail=f"Seat number that are already booked are : {booked_list} \n"
+                                            f"seat number you are going to book  are {integer_list}")
+
+            payload = {ticket.preferred_class: integer_list}
+            client.publish(token + ticket.preferred_class, json.dumps(payload))
+            # save ticket details to database
+            save_ticket = Ticket(
+                mobile_no=ticket.mobile_no,
+                preferred_class=ticket.preferred_class,
+                no_of_tickets=ticket.no_of_tickets,
+                seat_no=ticket.seat_no,
+                age=ticket.age
+            )
+
+            session = db_connect()
+            session.add(save_ticket)
+            session.commit()
+            return "ticket booked successfully"
+        except Exception as e:
+            print(e)
+            logger.error(e)
+
+
+class BookingDetails:
+    @staticmethod
+    def get_details():
+        try:
+            session = db_connect()
+            records = session.query(Ticket).all()
+            dict_records_clean = clean_record(records)
+            # Use pandas to convert the list of dictionaries to a DataFrame
+            df = pd.DataFrame(dict_records_clean)
+            # Use pandas to save the DataFrame to an Excel file
+            df.to_excel(file_path, index=False)
+        except Exception as e:
+            logger.error(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/delete_ticket.py

+import json
+import paho.mqtt.client as mqtt
+from scripts.config.application_config import host, can_topic, del_topic
+from scripts.config.db_connect import db_connect
+from scripts.database.model import Ticket
+from scripts.logging.logging import logger
+
+
+class db_handler:
+
+    @staticmethod
+    def delete_row(booking_id):
+        try:
+            client = mqtt.Client()
+            client.connect(host, 1883, 60)
+            # Soft delete a row in the ticket_details table
+            session = db_connect()
+            ticket = session.query(Ticket).filter(Ticket.booking_id == booking_id).first()
+            if ticket is not None:
+                ticket.deleted = True
+                session.commit()
+                no_seats = ticket.seat_no
+                data_of_list = no_seats.split(",")
+                integer_list = [int(item) for item in data_of_list]
+                data = {ticket.preferred_class: integer_list}
+                client.publish(del_topic, 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)
+
+    @staticmethod
+    def cancel_tickets():
+        try:
+            client = mqtt.Client()
+            client.connect(host, 1883, 60)
+            session = db_connect()
+            query = session.query(Ticket).update({Ticket.deleted: True})
+            # Commit the changes to the database
+            session.commit()
+            if query is not None:
+                # Publish the Message
+                message = "Show Cancelled"
+                client.publish(can_topic, message)
+        except Exception as e:
+            logger.error(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_the_data.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/model.py

+from datetime import datetime
+from sqlalchemy import Column, String, Integer, Boolean, DateTime
+from sqlalchemy.orm import declarative_base
+
+Base = declarative_base()
+
+
+class Ticket(Base):
+    __tablename__ = "ticket_details"
+    booking_id = Column(Integer, primary_key=True)
+    mobile_no = Column(String, unique=True)
+    preferred_class = Column(String)
+    no_of_tickets = Column(Integer)
+    seat_no = Column(String)
+    date_of_purchase = Column(DateTime, default=datetime.now())
+    age = Column(Integer)
+    deleted = Column(Boolean, default=False)

scripts/database/schema.py

+from pydantic import BaseModel
+
+
+class FilmTicket(BaseModel):
+    mobile_no: int
+    preferred_class: str
+    no_of_tickets: int
+    seat_no: str
+    age: int

scripts/logging/logging.py

+import logging
+import os
+from logging.handlers import RotatingFileHandler
+from scripts.config.application_config import file_name
+
+
+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_file = os.path.join(f"{file_name}_ERROR.log")
+    temp_handler = RotatingFileHandler(log_file,
+                                       maxBytes=100000000,
+                                       backupCount=5)
+    temp_handler.setFormatter(formatter)
+
+    __logger__.addHandler(temp_handler)
+
+    return __logger__
+
+
+logger = get_logger()

scripts/services/delete_ticket.py

+from fastapi import APIRouter
+from scripts.constants.end_points import EndPoints
+from scripts.core.handlers.delete_ticket import db_handler
+
+delete_ticket = APIRouter()
+
+
+@delete_ticket.post(EndPoints.delete_a_ticket, tags=["delete a ticket"])
+def delete_tickets(tid: int):
+    res = db_handler.delete_row(tid)
+    return {f'tickets {res} deleted'}
+
+
+@delete_ticket.get(EndPoints.cancel_all_tickets, tags=["cancel show"])
+async def cancel_all_tickets():
+    db_handler.cancel_tickets()
+    return {"Message": "Cancelled all Tickets"}

scripts/services/publish.py

+from fastapi import APIRouter
+from scripts.config.redis_connection import conn
+from scripts.constants.end_points import EndPoints
+from scripts.core.handlers.book_ticket import BookingDetails, BookTicket
+from scripts.core.handlers.create_redis_db import redis_db_create
+from scripts.core.handlers.get_all_the_data import seat_availability
+from scripts.database.schema import FilmTicket
+from scripts.logging.logging import logger
+
+router = APIRouter()
+
+
+@router.get(EndPoints.root, tags=["root"])
+def root():
+    return {"data": "ticket booking task"}
+
+
+@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.get(EndPoints.seat_availability,tags=["check seat availability"])
+def check_seats(ticket_class: str):
+    message = seat_availability(conn, ticket_class)
+    return message
+
+
+@router.post(EndPoints.book_ticket, tags=["book tickets"])
+def book_ticket(ticket: FilmTicket):
+    try:
+        return BookTicket.book_ticket(ticket)
+    except Exception as e:
+        print(e)
+        logger.error(e)
+
+
+@router.get(EndPoints.get_booking_details, tags=["get booking details"])
+def get_booking_details():
+    try:
+        BookingDetails.get_details()
+        return {"data": "list all the data"}
+    except Exception as e:
+        logger.error(e)
+        print(e)