Contact person: Business Client

Phone:Show

Email:Show

Location: Forest Hill, United States

Budget: Recommended by industry experts

Time to start: As soon as possible

Project description:
"I need a complete, browser-accessible ticket booking system that lets customers choose an event, select seats or ticket quantities, pay online, and instantly receive a digital ticket/confirmation email. The core build should sit entirely on the web—no native mobile work is required—so clean, responsive front-end code and a secure, well-documented back-end are essential.

Implement a Node.js server that provides a RESTful API for an event ticket booking system with the following core functionalities: 1. Initialize an event with a set number of available tickets. 2. Allow users to book tickets concurrently. 3. Implement a waiting list for when tickets are sold out. 4. Provide endpoints to view available tickets and the waiting list. 5. Handle ticket cancellations and automatic assignment to waiting list users. 6. Save the order details to a RDBMs.

Detailed Requirements

1. Server Setup

• Use [login to view URL] to create the server.

• Implement proper middleware for parsing JSON requests.

• Use a RDBMs to store the order details.


2. Data Management

• Use RDBMS or in-memory storage. Use migrations to manage the database schema.

• Design efficient data structures for storing event information, bookings,

and waiting lists.


3. API Endpoints

Implement the following RESTful endpoints:



a. POST /initialize

• Initialize a new event with a given number of tickets.

b. POST /book

• Book a ticket for a user.

• If sold out, add the user to the waiting list.

c. POST /cancel

• Cancel a booking for a user.

• If there’s a waiting list, automatically assign the ticket to the next

user in line.

d. GET /status/:eventId

• Retrieve the current status of an event (available tickets, waiting list

count).


4. Concurrency Handling

• Ensure thread-safety for all operations.

• Properly handle race conditions, especially for booking and cancellation

operations.


5. Error Handling

• Implement comprehensive error handling for all possible scenarios.

• Provide meaningful error messages in the API responses.


6. Test-Driven Development (TDD)

• Write unit tests for all core functionalities before implementing them.

• Achieve at least 80% test coverage.

• Include integration tests for API endpoints.


7. Code Quality

• Follow Node.js and JavaScript best practices.

• Use ES6+ features appropriately.

• Implement modular and maintainable code structure.


Implementation Steps

1. Set up the project structure and install necessary dependencies.

2. Write failing tests for each core functionality (TDD approach).

3. Implement the data structures for in-memory storage.

4. Create the [login to view URL] server and set up basic routing.

5. Implement each API endpoint, making the tests pass as you go.

6. Add concurrency handling and ensure thread-safety.

7. Implement comprehensive error handling.

8. Refactor and optimize your code.

9. Write integration tests for the API endpoints.

10. Document your code and API.


Evaluation Criteria

1. Correctness of implementation

2. Proper handling of concurrent requests

3. Effective use of Node.js asynchronous features

4. Comprehensive error handling and edge case management

5. Code organization, modularity, and readability

6. Test coverage and quality of tests

7. RESTful API design principles

8. Performance and scalability considerations


Submission Guidelines

1. Provide a GitHub repository with your complete code.

2. Include a [login to view URL] with:

• Setup and running instructions

• Brief explanation of your design choices

• API documentation

3. Ensure all tests are passing and include instructions for running them.

Bonus Points

• Implement rate limiting for the API endpoints.

• Add basic authentication for sensitive operations.

• Implement a simple logging system for tracking operations" (client-provided description)