Ecosyste.ms: Awesome
An open API service indexing awesome lists of open source software.
https://github.com/gunjankadu/sales-order-system
An Order Management System that helps control the process between a customer placing an order and the product going out for delivery. It tracks sales, stock and fulfilment as well as ensuring all processes and people in-between are kept informed and up-to-date.
https://github.com/gunjankadu/sales-order-system
hibernate hibernate-orm java mongodb mysql spring-boot
Last synced: 5 days ago
JSON representation
An Order Management System that helps control the process between a customer placing an order and the product going out for delivery. It tracks sales, stock and fulfilment as well as ensuring all processes and people in-between are kept informed and up-to-date.
- Host: GitHub
- URL: https://github.com/gunjankadu/sales-order-system
- Owner: GunjanKadu
- License: unlicense
- Created: 2020-04-15T21:17:02.000Z (over 4 years ago)
- Default Branch: master
- Last Pushed: 2022-12-16T05:47:12.000Z (almost 2 years ago)
- Last Synced: 2023-03-04T10:30:00.666Z (over 1 year ago)
- Topics: hibernate, hibernate-orm, java, mongodb, mysql, spring-boot
- Language: Java
- Homepage:
- Size: 473 KB
- Stars: 4
- Watchers: 2
- Forks: 1
- Open Issues: 14
-
Metadata Files:
- Readme: README.md
- License: LICENSE
Awesome Lists containing this project
README
# Sales Order System
## Table of Contents
* [Summary](#summary)
* [Development](#development)
* [Running Locally](#running-locally)
* [Running Unit Tests](#running-unit-tests)
* [Running Integration Tests](#running-integration-tests)
* [Running End2End Tests](#running-e2e-tests)
* [Code Quality Analysis - SonarQube](#code-quality-analysis)
* [Running with MySQL](#running-with-mysql)
* [Running with MongoDB](#running-with-mongodb)
* [Technical Overview](#technical-overview)
* [High Level Architecture](#high-level-architecture)
* [Back End](#back-end)
* [Front End](#front-end)
* [Database Design](#database-design)
* [Application Patterns](#application-patterns)
* [Declarative Programming](#declarative-programming)
* [Security Issues](#security-issues)
* [Testing](#testing)
* [Integration Testing](#integration-testing)
* [End 2 End Testing](#e2e-testing)
* [Team Members](#team-members)
* [Project Demo](#project-demo)
* [Technology/Tool Stack](#tech-tool)
This is a very small full-stack web application that is used as a sample and is for pure demonstration purposes.
1) Checkout code
```
git clone https://github.com/GunjanKadu/Sales-Order-System.git
```
2) Do a local build
```
mvn clean package
```
... will compile the sources, package up the war file
3) Run application
go into the online-application directory and execute following command:
```
mvn tomcat7:run-war
```
uses maven tomcat7 plugin to run the application within an embedded Apache Tomcat web container
once the application loaded, navigate to:
```
http://localhost:8080/online-application/login
```
some sample credentials can be found configured in Spring's application-security.xml configuration file.
```
mvn test
```
... this will run all unit test within the suite of tests
or
from your IDE, just navigate to the unit test class and click on the IDE's 'run' button
#### Running Integration Tests
```
mvn verify
```
... this will run all integration test within the suite of tests.
or
from your IDE, just navigate to the integration test class and click on the IDE's 'run' button
[TBD]
#### Sonar - Code Quality Analysis
Use Sonar (SonarQube) to run code quality analysis on the project. A sonar-project.properties file provided.
Will need SonarQube server and Sonar Runner so need to download them both from the SonarQube website and follow the installation instructions.
Assuming Sonar is installed (with Sonar Runner on the environment path), on CLI run:
1. Start the SonarQube Server
2. Navigate to project root directory and execute:
```
sonar-runner
```
#### Running with MySQL
It is also possible to run with MySQL. You need MySQL to be installed. Download from the MySQL website and follow installation instructions.
1. Start up MySQL server on your system
2. Configure Spring's application-datasource.xml configuration file to connect to MySQL:
Uncomment below as specified:
```xml
```
Assumming MongoDB is installed on system. If not, can download it from MongoDB website and follow installation instructions.
Start up MongoDB Database Server:
```
./mongod
```
Open up MongoDB Database client:
```
./mongo
```
Load the mongodb javascript file which populates some sample data
```
load("mongodb.js")
```
The application is just a simplistic monolithic application built with several layers. In summary, back-end is written in Java which connects to a back-end in-memory relational database (HSQL). Can also connect to other relational databases (MySQL). Application is scafolded by Spring Framework. Model-View-Controller (MVC) architectural pattern is used to separate the front-end from the back-end. This is achieved by Spring Web MVC. This application would then be deployed on an embedded web container (Apache Tomcat).
The front-end is plainly JSP with a bit of JSTL here and there. Dandelion Databases also used to implement tables in the UI. Basic CSS for styling. Bootstrap provides the front-end framework for this.
* The back-end is completely built using Java (Java 8 compiled)
* It is bootstrapped by Spring Framework
* Database is a RDBMS (Relational Database Management System):
* default in memory-db (HSQL)
* MySQL supported too
* Spring Data JPA provides the Data Access Abstraction
* Persistence done using JPA (Hibernate the implementation)
* JSP serves front-end html content...
[TBD]
##### Transaction Script Pattern
This application is very simple. It is a web application that currently provides basic CRUD operations. Everything operational is viewed as a business transaction which is executed down through the various layers. Therefore, an anemic domain model is used as opposed to a pure object-oriented domain model. This is sufficient and ideal because at this moment there is not much (if any) complex business logic processing that is required.
##### Service Layer Pattern
Defining the application's boundary and setting the available operations from the perspective of interfacing client layers (front-end). It encapsulates the application's business logic, controlling transactions and coor-dinating responses in the implementation of its operations.
e.g.
```java
@Service("itemServiceImpl")
@Transactional
public class ItemServiceImpl implements ItemService {
@Autowired
private ItemRepository itemRepository;
...
}
```
##### Repository Pattern
An object-oriented view of the data store underneath providing an extra layer of abstraction (Spring Data JPA) in front of the data access capabilities of the Data Mapper pattern. Object Relational Mapping framework (Hibernate) is used to achieve this effect of mapping the differences between relational database tables and the domain model. JPA's entity manager encapsulates the data access element (Data Access Object pattern).
e.g. of a Spring Data JPA Repository
```java
@Repository
public interface ItemRepository extends JpaRepository {
}
```
Spring Framework's annotation support (component scanning) is done to do this taking advantage of Spring Framework's core abilities - Dependency Injection provided by the Inversion of Control (IOC) container.
```java
@Controller
public class OrderController {
private static final Logger logger = LoggerFactory.getLogger(OrderController.class);
@Autowired
@Qualifier("orderServiceImpl")
private OrderService orderService;
@Autowired
@Qualifier("customerServiceImpl")
private CustomerService customerService;
@Autowired
@Qualifier("itemServiceImpl")
private ItemService itemService;
@Autowired
@Qualifier("orderFormValidator")
private OrderFormValidator orderFormValidator;
```
Another example from the Customer model object:
```java
@Entity
@Table(name = "customer")
@Getter
@Setter
@NoArgsConstructor
@EqualsAndHashCode(exclude = "orders")
@ToString
public class Customer {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Column(name = "customer_id")
private int customerId;
@NotNull(message = "{error.null.firstname}")
@NotBlank(message = "{error.blank.firstname}")
@NotEmpty(message = "{error.empty.firstname}")
@Pattern(regexp = "[a-zA-Z]*", message = "{error.invalid.firstname}")
@Column(name = "customer_firstname", nullable = false, length = 50)
private String firstName;
@NotNull(message = "{error.null.lastname}")
@NotBlank(message = "{error.blank.lastname}")
@NotEmpty(message = "{error.empty.lastname}")
@Pattern(regexp = "[a-zA-Z]*", message = "{error.invalid.lastname}")
@Column(name = "customer_lastname", nullable = false, length = 50)
private String lastName;
```
Lombok Project used to generate getters/setters/toString/equals and hashcode to remove the boilerplate code
The application enables login/logout feature which was implemented using the basic features of the Spring Security module of the Spring Framework.
The following application-security.xml Spring configuration file shows key security configurations:
```xml
....
Integration Testing is implemented using Spring's Test Context Framework. An in-memory Database (HSQL) is used.
End 2 End Testing (Acceptance Testing) is done using Cucumber-JVM. This is available under the test-automation sub module. The intent of this is to provide end to end automation of the full stack web application. Maybe, can integrate Selenium in the future which would allow automation of the web application on web browsers. But for now, cucumber tests are written in the back-end code. Acceptance criterias are written in the .feature files using the Gherkin language. This area needs improvement.
Note that End 2 End testing for this project is still WIP.
| Front End | Back End | Database | Testing | Other |
|:-------------------- |:--------------- |:--------------- |:------------------- |:-------------- |
| HTML | Java 8 | HSQL (HyperSQL) | JUnit | SLF4j - Log4j |
| CSS | Spring Core | MySQL | AssertJ | Maven |
| JS | Spring Web MVC | MongoDB | Mockito | Tomcat |
| Bootstrap | Spring Data JPA | | Cucumber-JVM | SonarQube |
| JSP | Spring Security | | Spring Test Context | Lombok |
| JSTL | JPA - Hibernate | | | |
| Dandelion DataTables | JTA | | | |
| | Bean Validation | | | |