wajahatkanju/artmart

E-Commerce App

Description

This is a private Django e-commerce app for managing an online store. It provides functionality for product management, user authentication, shopping cart, order processing, and more.

Features

• User registration and authentication
• Product catalog with browsing and searching
• Product details, including images, descriptions, and pricing
• Shopping cart functionality
• Order placement and processing
• User account management
• Admin panel for site management

Technologies Used

• Django: The web framework used for developing the app
• Python: The programming language used for backend development
• HTML/CSS: Used for frontend templates and styling
• PostgreSQL: The database system used for data storage
• Other libraries and frameworks as required (e.g., Django REST Framework, Bootstrap, etc.)

Installation

1. Clone the repository:

2. Change into the project directory:

3. Create and activate a virtual environment: python3 -m venv env source env/bin/activate

4. Install the dependencies:

5. Set up the database:

6. Run the development server:

7. Access the app at http://localhost:8000 in your web browser.

Usage

• Register a new user account or login with an existing account.
• Browse the product catalog and view product details.
• Add products to the shopping cart and proceed to checkout.
• Complete the order by providing the required information.
• Manage user account settings and view order history.

Contributing

Project is open for contribution

License

This project is licensed under the MIT License. See the LICENSE file for more details.

Contact

For questions or inquiries, please contact:

• Wajahat AHmad: [email protected]

artmart's Issues

Create Scripts for Database Initialization

Create Scripts for Database Initialization

Issue Description

To improve the development and testing process, we need to create scripts that allow us to recreate the database from scratch and populate it with initial data for all the models in our Django project. This will help ensure a consistent and easily reproducible database setup for the team.

Tasks

• Develop a script (e.g., a Python script or Django management command) that recreates the database schema based on our project's models.
• Include logic to create all necessary database tables, set up relationships, and apply migrations.
• Add functionality to populate the database with initial data for essential models (e.g., default user roles, sample products, categories, etc.).
• Ensure the script is well-documented, with clear instructions on how to use it.
• Test the script thoroughly to ensure it works reliably and consistently.
• Create a README or documentation section explaining how to use the script for database initialization.
• Consider options for customizing the initial data based on development and testing needs.

Expected Results

• The script should be able to recreate the database schema and populate it with initial data without errors.
• Documentation should be clear and easy to follow, making it simple for team members to use the script effectively.
• The script should be flexible enough to accommodate changes to the database structure and initial data in the future.

Implement Custom User Model

Implement Custom User Model

Issue Type: Feature Request

Description

Background

In our project, we require a custom user model to better align with our application's specific requirements. The default Django User model, while excellent for many use cases, does not provide the flexibility and additional fields we need to support our multi-role e-commerce platform.

Requirements

1. User Roles: We need the ability to define and manage different user roles such as admin, staff, delivery boy, sellers, vendors, and customers. Each role should have its own set of permissions and associated data.

2. Additional User Fields: Our custom user model should allow us to store additional information about users beyond what the default User model provides, such as shipping addresses, phone numbers, and vendor-specific data.

3. Authentication Methods: We may need to implement authentication methods beyond the default username and password, such as social login (OAuth) or multi-factor authentication (MFA).

4. Scalability and Extensibility: Our custom user model should be designed with scalability and extensibility in mind to accommodate future changes and business requirements.

5. Granular Permissions: We require fine-grained control over user permissions and access control, allowing us to implement custom authorization logic for different user roles.

Potential Roles

• Customer: Regular users who browse, search for products, add items to their cart, make purchases, and manage their profiles.

• Vendor/Seller: Individuals or businesses who list and manage their products on the platform. They may have their own dashboards to add/edit products, view orders, and manage inventory.

• Admin: Users with full control over the e-commerce platform. They can manage users, review and moderate vendor/seller listings, monitor site analytics, and handle customer support.

• Staff: Staff members such as customer support agents, content managers, and other employees responsible for assisting customers, updating product listings, and managing content on the site.

• Delivery Personnel/Delivery Boy: Individuals responsible for fulfilling orders by picking up products from vendors, preparing packages, and delivering them to customers. They may have access to order information and tracking tools.

• Customer Support: Customer support agents who handle customer inquiries, complaints, and issues. They may have specialized access to customer data and communication tools.

• Warehouse/Inventory Manager: If the app manages inventory, these users may be responsible for tracking stock levels, restocking products, and managing the physical inventory.

• Marketing/Analytics Team: Users responsible for analyzing user data, tracking user behavior, and developing marketing campaigns to improve user engagement and sales. They may need access to analytics tools and data.

• Affiliate Partners: Users who promote products through affiliate marketing programs and earn commissions on sales they generate.

• Accountants/Finance Team: Users responsible for handling financial transactions, taxes, and financial reporting.

• System Administrators/Developers: Individuals responsible for maintaining server infrastructure, ensuring security, and developing new features.

• Superusers/Supervisors: Users with elevated permissions who can perform actions that regular admins cannot. They may have unique access to critical functions or settings.

• Content Creators/Bloggers: Users responsible for creating and managing blog posts and articles if the e-commerce app includes a blog or content section.

• Reviewers/Raters: Users who provide ratings and reviews for products and services, potentially influencing product rankings based on their reviews.

• Guest Users: Users who do not create accounts but can make one-time purchases. Their data may be stored temporarily for order processing.

Issue with Django Admin LTE Related Fields

Issue with Django Admin LTE Related Fields

Description:

Issue
The Django Admin LTE interface is experiencing problems when navigating to related fields.

Details

• Environment: This issue has been observed in a Django project using the Django Admin LTE package.
• Problem Description: When trying to access related fields within the Django Admin interface, such as ForeignKey or OneToOneField, users are encountering unexpected behavior or errors. This includes but is not limited to:
  • Incorrect rendering of related field widgets.
  • Missing or broken links when trying to follow relations.
  • Inconsistent behavior when editing related objects.

Steps to Reproduce:

1. Install Django Admin LTE in a Django project.
2. Create models with related fields, such as ForeignKey or OneToOneField.
3. Access the Django Admin interface and try to interact with the related fields.

Expected Behavior
The Django Admin LTE interface should seamlessly handle related fields, allowing users to view, edit, and navigate related objects without encountering errors or inconsistencies.

Actual Behavior
The behavior described above is observed, making it challenging to work with related fields in the Django Admin LTE interface.

Additional Information

• This issue may be related to compatibility problems between Django Admin LTE and the Django version being used.
• The problem may also be affected by customizations or overrides made to the Django Admin LTE templates or styles.
• Developers are encouraged to provide code examples, error messages, or stack traces to help diagnose and address the issue.

Possible Solutions

• Check for updates to the Django Admin LTE package to ensure you are using the latest version.
• Review and compare customizations made to Django Admin LTE templates and styles with the default configurations to identify any discrepancies.
• Examine the compatibility between Django Admin LTE and the specific version of Django you are using. Upgrade or downgrade Django if necessary.
• Test the issue in a clean, minimal Django project to rule out any interference from other third-party packages or custom code.

Implement Shopping Cart Functionality

Title: Implement Shopping Cart Functionality

Description:
We need to implement a shopping cart feature to enhance the user experience on our e-commerce platform. Currently, users can browse and view products, but they cannot add them to a cart for easy checkout. Implementing a shopping cart will allow users to:

• Add products to their cart.
• View and edit the items in their cart.
• Proceed to checkout with the selected items.

Key functionalities to include in this feature:

1. Add to Cart: Users should be able to add products to their cart from product detail pages or product listings.

2. Cart Page: Create a dedicated cart page where users can see a summary of their selected items, including product names, quantities, prices, and a subtotal.

3. Edit Cart: Allow users to update the quantity of items or remove products from the cart on the cart page.

4. Cart Persistence: Ensure that the cart is persistent across user sessions. Users should be able to leave the site and return later to find their cart items still intact.

5. Calculate Total: Calculate the total price of items in the cart, including any applicable taxes or shipping costs.

6. Proceed to Checkout: Provide a clear and intuitive "Proceed to Checkout" button that guides users to the checkout process.

7. Guest Cart: Allow both registered and guest users to use the shopping cart.

By implementing this shopping cart functionality, we aim to improve the user experience, increase the likelihood of conversions, and streamline the checkout process for our customers.

Test the Products App in Our Django Project

Test the Products App in Our Django Project

Issue Description

We need to thoroughly test the Products app in our Django project to ensure it functions correctly and meets our requirements. This testing phase is essential for maintaining code quality and ensuring a reliable user experience.

Tasks

• Review the Products app's documentation and requirements to understand its functionality.
• Set up a testing environment if not already in place.
• Create test cases and test scenarios to cover all aspects of the Products app's functionality.
• Write unit tests, integration tests, and end-to-end tests as needed.
• Execute the tests and verify that they pass successfully.
• Identify and document any issues or unexpected behavior encountered during testing.
• Collaborate with developers to resolve and fix any identified issues.
• Re-run the tests to confirm that the issues have been resolved.
• Verify that the app functions correctly and meets the project's requirements.
• Update the testing documentation with any new test cases or changes.

Expected Results

• All test cases should pass without any failures.
• The Products app should behave as expected, following the defined requirements.
• Any issues or bugs found during testing should be documented and addressed.

Strengthen Logs and Error Handling

Issue Description

Objective

To enhance the robustness of logs and error handling mechanisms, ensuring the platform operates with utmost reliability and resilience.

Tasks

1. Assessment and Analysis

   • Conduct a meticulous review of the current logging infrastructure within the project.
   • Identify areas necessitating refinement and enhancement.

2. Error Handling Strategy

   • Craft an intricate error handling strategy that gracefully manages unexpected errors and exceptions.
   • Develop mechanisms to ensure system stability even in the face of unforeseen issues.

3. Structured Logging

   • Implement structured logging, encompassing essential attributes like timestamps, severity levels, and contextual information.
   • Ensure log entries adhere to a consistent and informative format.

4. Log Management

   • Configure log rotation to mitigate log file growth and maintain efficient log management practices.
   • Verify that logs encompass all critical events and errors without omission.

5. Alerting and Notifications

   • Introduce an alerting and notification system to promptly respond to critical errors that demand immediate attention.

6. Documentation

   • Document comprehensive logging and error handling procedures for the development team.
   • Enhance existing project documentation with insights into error codes, common error scenarios, and troubleshooting guidelines.

7. Testing

   • Execute rigorous testing to validate that logs accurately capture expected data.
   • Verify that error handling gracefully manages exceptions and error messages are meaningful.

8. Integration with Monitoring Tools

   • Consider integrating with industry-standard monitoring and alerting tools for real-time error detection and response.

Expected Results

• The logging infrastructure in the project should exhibit a marked improvement in terms of clarity, structure, and actionable insights.
• Error handling should be agile, ensuring smooth exception management and clear, user-friendly error messages.
• Critical errors should trigger immediate alerts, expediting the resolution process.
• Development team members should possess clear, well-documented guidelines for managing logs and handling errors.
• The project's resilience to unexpected issues should enhance the overall user experience.

Implement Gettext Lazy for Future Translations

Issue Title

Implement Gettext Lazy for Future Translations

Issue Description

Note: This issue is a proposal for optimizing our project's translation infrastructure even though we currently have no translations. By adopting Gettext Lazy for translations from the start, we can prepare for future localization needs efficiently.

Problem

While our project does not currently have translations, it's important to consider a translation strategy as part of our development process. Waiting until translations are needed may result in additional development effort and potential performance issues later on.

Solution

What is Gettext Lazy?

Gettext Lazy is an optimization technique for translating strings in software applications. It defers the translation of strings until they are actually needed, providing the following benefits:

1. Future-Proofing: Implementing Gettext Lazy now ensures that we are well-prepared for future translation needs. When the time comes to introduce translations, the infrastructure will already be in place.

2. Performance Improvement: By translating strings only when necessary, we can reduce the initial overhead of loading and parsing translation files, resulting in faster application startup times.

3. Reduced Memory Usage: Since translations are loaded on-demand, we can avoid loading the entire translation catalog into memory at once. This leads to lower memory usage, which is especially important for large applications or those running in resource-constrained environments.

4. Improved Responsiveness: Gettext Lazy allows us to load translations in the background, improving the responsiveness of our application. Users won't experience delays caused by loading translations during startup.

Proposed Implementation

To implement Gettext Lazy for future translations, we need to make the following changes in our project:

1. Update Translation Infrastructure: We'll need to update our translation infrastructure to support Gettext Lazy. This may involve changes to our translation framework or library.

2. Code Refactoring: We'll refactor our code to use Gettext Lazy where appropriate. Even though we have no translations now, we'll prepare our codebase to seamlessly support translations when they are introduced.

3. Testing: We'll thoroughly test the implementation to ensure that it works correctly and doesn't introduce regressions.

4. Documentation: We'll update our documentation to reflect the changes in the translation process, even if we currently have no translations, making it easy for other developers to understand and follow the new approach.

Additional Context

If there are any additional details, considerations, or potential challenges related to implementing Gettext Lazy for future translations in our project, please provide them here.

Contributors

Tag individuals or teams who might be interested in or responsible for implementing this change, even if it's a preemptive measure for future use.

Checklist

• The proposal has been discussed and agreed upon by the team.
• We are considering future translation needs in our project planning.
• The necessary resources and expertise are available to implement Gettext Lazy.
• We have considered potential performance gains and tested the proposed changes.
• Documentation will be updated to reflect the new translation approach, even if no translations are currently present.

Please feel free to adapt this template to your specific project and requirements when creating the GitHub issue. This proactive approach to translation optimization can help streamline future localization efforts.

Add Delivery Boy System

Task: Add Delivery Boy System

Issue Description

Summary

We need to implement a Delivery Boy System to improve our delivery processes. This task involves adding a dedicated mobile application or web interface for delivery personnel to efficiently manage their deliveries, track routes, and provide real-time updates to customers.

Objective

The objective of this task is to initiate discussions and gather input on adding a Delivery Boy System to our existing infrastructure.

Key Features

• Create a user-friendly interface for delivery personnel.
• Implement real-time tracking of delivery orders.
• Integrate with our existing order management system.
• Optimize delivery routes for efficiency.
• Implement notifications for both customers and delivery personnel.
• Provide order status updates.

Broken UI in Django admin after adding django-nested-inline package

Issue Title:

Broken UI in Django admin after adding django-nested-inline package

Issue Description:

I encountered an issue with the Django admin interface after adding the django-nested-inline package to my project. The UI elements are not rendering correctly, which makes it difficult to use the admin interface with this package enabled.

Steps to Reproduce:

1. Install the django-nested-inline package in a Django project.
2. Add a model to the project that uses nested inline admin forms with the package.
3. Navigate to the Django admin interface.
4. Observe the broken UI elements.

Expected Behavior:

The Django admin interface should display correctly, with no broken UI elements, when using the django-nested-inline package.

Actual Behavior:

The UI elements in the Django admin interface are broken and not rendering as expected.

Additional Information:

• Django version: 4.2

• django-nested-admin version: 4.0

• Screenshots

• Before
  
  
  

• After
  
  
  

Possible Solution:

The issue appears to be linked to conflicts between Jazzmin and nested-admin styles. It may be resolved through template customization.

Create a Full Customer App

Issue Description:
We would like to request the creation of a full customer app within our project. This app will allow us to manage customer data, including names, email addresses, phone numbers, packages, and wallet balances. Having a dedicated customer app will streamline our operations and enhance our customer management capabilities.

App Features:

• Customer registration and management.
• Storing customer information: Name, Email Address, Phone Number, Package, Wallet Balance.
• User-friendly interface for adding, editing, and deleting customer records.
• Integration with the existing project for seamless data interaction.

Feel free to modify and customize this template to suit your specific project requirements and workflow. Once you've filled in the details, click the "Submit new issue" button to create the GitHub issue.