Ecommerce Makeup Sales

Introduction (Week1)

Shopping, especially make-up shopping is what almost every girl loves to do. Nowadays, since we are living in a more advanced technology and gadgets that even the simplest things, like shopping, can be done with the aid of internet and computers. By using getthelook.com you can shop easily online and follow the beauty trends without leaving the house!

Goals&Objectives

• Provide an effective online shopping platform with popular and various make up products with suitable and enlightening descriptions
• With one simple click deliver a product to a customer’s door, without having them to step out of the house.
• Make the online shopping process as easy and as effective as possible

Advantages of getthelook.com

• Convenient, no need for an extra effort since it enables buyers to purchase products easily with just one click
• Variety of products with visual images
• Products suitable for different budgets
• Different brands, different models; costumers are not limited to what’s in the sore racks and stock rooms.
• The ability to price compare; it is easy to compare and find the best price instantly
• Shop 24/7: No working hour limitations

Major Software Functions

Users are able to:

• Log in and sign up
• Add products to the cart before or after logging in
• Buy products by providing the card information after logging in
• View categories, Choose a brand, Choose a product
• Add and delete various products to/from the cart

Admins are able to:

• Update/delete products
• Update/delete categories
• View carts
• View users

Technical Documentation

Information of the System Environment

The Project is developed on Sony Vaio Tap 11. It’s Windows 8 64-bit, Core i5-4210Y (1.50GHz/1.90GHz), 4GB RAM, Intel HD Graphics 4200. First of all we downloaded MySql Web Community Edition and Netbeans with Tomcat extension. In order to build our e-commerce website, we used MySql, JDBC, JSP, HTML and Java. Since we used HTML, Java and MySql we had to set up a connection among them. As displayed in the Figure below HTML and Java are connected by using JSP while Java and mySql are connected by using JDBC.

Modules of getthelook.com

Shopper Module

Main and Login Page (index.jsp) (week 4)

We created both Html and java codes together in this file in order to display the main page figure below. We created style sheet to design the index page. (stylesheet.css)

Sign-up Page

This page will be developed soon.

Category Viewing Page (week 5)

This file displays all the categories available to the user. We created style sheet to design the category view page. (categorystylesheet.css)

Product Viewing Page (week-6)

This file displays all the products available to the user. We created style sheet to design the product view page. (productstylesheet.css)

Adding to Cart Page (Week7)

Manage My Account Page

This page will be developed soon.

Shopper Logout Page (week7)

Enables user to logout and releases the session attributes. (Current Shopper and Current Cart)

Admin Module

Main Admin Page

Admin Login Page (week8)

Enables admins to log in to admin page and puts the current admin into the session.

Viewing Categories (week9)

Displays the lists of the categories,update and delete options are available at this page.

Forming Category (week9)

Enables admin to update and add a category.

Listing Product (week10)

Displays the lists of the products, update and delete options are available at this page.

Forming Product (week10)

Enables admin to update and add a product

Listing Cart (week11)

Displays the available carts of the shoppers in a table, Add option is available at this page.

Forming Cart (week11)

Enables admin to add a new cart

Listing User (week8)

Displays the lists of the users, Update and Delete options are available at this page.

Forming User(week8)

Enables admin to update and add a user.

Major Problems currently encountered (week7-8)

• First we named the user as shopper, then when we decided to rename as users after adding the specific usertype admin and shopper, we had to drop shopper table and create a whole new table called users. This leaded us a time waste, because we also had to check all the codes and make the necessary changes.
• Total amount of the products does not increase in the database as we add more products
• new added users cannot add products when they first login however they sign out and login again they can.
• users should not proceed to the checkout page if they balance is 0.
• paypal option should be added as an option to credit card at the checkout
• credit card,cvv,expiration date and password validation should be created

Data Structures and Variables (Week 2-3)

Connection to Database

By using BaseManager class we can connect database to the Java. In order to avoid code repetition about the connection we formed a manager class, named BaseManager to make all connections at once. In order to make the connection possible we later created separate java files for each table (Category, Product, Users, Cart, Cartline). At the beginning of the coding process first there were java files just for the Category and Product tables. Once we progressed and formed other tables we created separate java files for each of them. In this way we avoided the need for putting URL for each separate file by using BaseManager class. By using Polymorphism, we created BaseManager class and extended subclasses so that we do not have to write these methods over and over again. Following are the extended classes:

• Category Manager: Provides the connection and maintenance between Database (category) and Java files, synchronizes Category.java entities.
• Product Manager: Provides the connection and maintenance between Database (product) and Java files, synchronizes Product.java entities.
• CartLineManager: Provides the connection and maintenance between Database (cartLine) and Java files, synchronizes CartLine.java entities.
• User Manager: Provides the connection and maintenance between Database (User) and Java files, synchronizes User.java entities.

Database Explanation

Our Project’s database performs all CRUD ( Create – Read - Delete – Update) actions. The explanation of each database table and their entities are explained below in the formation order. We first created the Category table. It’s formed of a main category and two sub categories. Root category is composed of skin, lips and eyes. Then each parent category is divided into sub categories: (Skin into concealer, powder, foundation), (Lips into lip balm, lipstick, lip pencil), (Eyes into eye pencil, eye shadow, mascara). After that step, each sub category is divided into another sub category. So system works recursively. The parentCategory id of the root category (skin, lips, eyes) are assigned as NULL. In this form, each child category is linked to its parent category by using parentCategory id. A simple display for this system is shown below in order to make the explanation more clear.

Second table that we created was the products table. The products table is connected to the categories table by a foreign key. In order to connect these tables with java, we created categorymanager and productmanager java classes. So, these tables became identifiable to the Netbeans. These two tables are related to the products. However, ecommerce website is composed of many different components. A developer needs to think about the purchasing step, customers, and registered users in order to create a successful and effective shopping platform. Therefore, we moved to the next step that is creating cart table and cartline table for the shopping basket process. Cart table is the main table for the payment process and storing the products that the shopper plans to purchase. Cartline is for storing each product on cart table line by line. If a user decides to purchase more than one product for the same item, it is stored in the same cartline reducing the data redundancy. When a shopper decides to purchase a product; for example Dior lipstick, the product is added to the basket. Also, in our project a user can add more than one product and if she/he changes her mind she can also delete it. Cartline is connected to the product whereas cart is connected to the cartline by a foreign key. Last step in the database table creation was the user table. A shopping process involves a user and a product. So in order to purchase a product, shopper needs to be registered to the system so that her name and address information are stored in the database for the purchasing. Since a specific cart is assigned to a specific user, users table is connected to cart table by a foreign key. When a user adds, removes a product all the modifications are made within the same assigned cart.

Data Structures

Tables:

• Cagetory

• • categoryId BIGINT (20) : the unique number for a category – primary key
  • categoryName VARCHAR (100): the name of the root and child categories
  • imagePath VARCHAR (200): the image Path is used to store and manipulate 2-dimensional data. Image url for image path that will take the image file to image path to get the images.
  • parentCategoryId BIGINT (20): this is the id required for the child subcategory to derive from the root category.

• Product

• • productId BIGINT(20): the unique number for a product – primary key
  • productName VARCHAR(100) : the name of the product that the user will purchase
  • salesPrice FLOAT: the amount of the Money that the user is required to pay in order to purchase the product.
  • categoryId BIGINT(20): holds the unique number for each category – foreign key
  • productAbstract VARCHAR(250): Main header for the product
  • productBodyVARCHAR(2500): Explanatory header for the product
  • imagePath VARCHAR(100): the image Path is used to store and manipulate 2-dimensional data. Image url for image path that will take the image file to image path to get the images.

• Cartline

• • cartLineId BIGINT(20): the unique number for the cart line – primary key
  • cartId BIGINT(20): holds the unique number for each cart. – foreign key
  • productId(20): holds the unique number for each product – foreign key
  • salesQuantity FLOAT: the product amount for the same item
  • lineAmount FLOAT: the price for the line that holds the product information

• Cart

• • cartId BIGINT(20): the unique number for the cart – primary key
  • userId(20): the unique number for the user – foreign key
  • totalAmount FLOAT: the total price for all items in the cart
  • cardNumber VARCHAR(45): credit card number for the shopper

• Users

• • userID BIGINT(20): The unique number for the user – primary key
  • userName VARCHAR(45): The name of the user (shopper or admin)
  • userPassword VARCHAR(45): The specified password required to access to system
  • personName VARCHAR(45): The name of the shopper or admin
  • addressLine1 VARCHAR(100): Street Number
  • addressLine2 VARCHAR(100): House Number and Zip
  • provinceName VARCHAR(45): the name of the city
  • userType TINYINT(4): the type of the user (0=admin, 1=shopper)

Entity Relationship Diagram

In this Figure, we can see the relationships between tables and also one-to many relationships.

Team Members

From left to right: Ezgi Guneren, Irmak Guneysu, Ece Islamoglu