//AppConfig.java
package com.mindtree.configuration;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.EnableWebMvc;

@Configuration
@EnableWebMvc
@ComponentScan(basePackages = {"com.mindtree"})
public class AppConfig {


}
//-------------------------------------------------------------------------------------------

//AppInitializer.java

package com.mindtree.configuration;

import org.springframework.web.servlet.support.AbstractAnnotationConfigDispatcherServletInitializer;

public class AppInitializer extends AbstractAnnotationConfigDispatcherServletInitializer
{

	@Override
	protected Class<?>[] getRootConfigClasses() {
		return new Class[] {AppConfig.class};
	}

	@Override
	protected Class<?>[] getServletConfigClasses() {

		return new Class[] {};
	}

	@Override
	protected String[] getServletMappings() {

		return new String[] {"/"};
	}

}
//-------------------------------------------------------------------------------
//HibernateConfiguration.java

package com.mindtree.configuration;
import java.util.Properties;

import javax.sql.DataSource;

import org.hibernate.SessionFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;
import org.springframework.core.env.Environment;
import org.springframework.jdbc.datasource.DriverManagerDataSource;
import org.springframework.orm.hibernate5.HibernateTransactionManager;
import org.springframework.orm.hibernate5.LocalSessionFactoryBean;
import org.springframework.transaction.annotation.EnableTransactionManagement;

@Configuration
@ComponentScan(basePackages = { "com.mindtree" })
@EnableTransactionManagement
@PropertySource(value = { "classpath:application.properties" })
public class HibernateConfiguration {

	@Autowired
	private Environment environment;

	@Bean
	public LocalSessionFactoryBean sessionFactory() {
		String[] entityPackage = new String[] { "com.mindtree" };
		LocalSessionFactoryBean sessionFactory = new LocalSessionFactoryBean();
		sessionFactory.setDataSource(dataSource());
		sessionFactory.setPackagesToScan(entityPackage);
		sessionFactory.setHibernateProperties(hibernateProperties());
		return sessionFactory;
	}

	@Bean
	public DataSource dataSource() {
		DriverManagerDataSource dataSource = new DriverManagerDataSource();
		dataSource.setDriverClassName(environment.getRequiredProperty("jdbc.driverClass"));
		dataSource.setUrl(environment.getRequiredProperty("jdbc.url"));
		dataSource.setUsername(environment.getRequiredProperty("jdbc.username"));
		dataSource.setPassword(environment.getRequiredProperty("jdbc.password"));
		return dataSource;
	}

	private Properties hibernateProperties() {
		Properties properties = new Properties();
		properties.put("hibernate.dialect", environment.getRequiredProperty("hibernate.dialect"));
		properties.put("hibernate.show_sql", environment.getRequiredProperty("hibernate.show_sql"));
		properties.put("hibernate.format_sql", environment.getRequiredProperty("hibernate.format_sql"));
		properties.put("hibernate.hbm2ddl.auto", environment.getRequiredProperty("hibernate.hbm2ddl.auto"));
		properties.put("hibernate.connection.release_mode", environment.getRequiredProperty("hibernate.connection.release_mode"));
		properties.put("hibernate.connection.shutdown", environment.getRequiredProperty("hibernate.connection.shutdown"));
		return properties;
	}

	@Bean
	@Autowired
	public HibernateTransactionManager transactionManager(SessionFactory s) {
		HibernateTransactionManager txManager = new HibernateTransactionManager();
		txManager.setSessionFactory(s);
		return txManager;
	}
}

//-----------------------------------------------------------------------------------------------------------------------------------

//EmployeeController.java

package com.mindtree.controller;

import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.http.ResponseEntity.BodyBuilder;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;

import com.mindtree.dto.ResultDTO;
import com.mindtree.entity.Employee;
import com.mindtree.service.EmployeeService;

@RestController
public class EmployeeController {

	@Autowired
	private EmployeeService employeeService;

	@PostMapping("/employee/")

	public ResponseEntity<ResultDTO> save(@RequestBody Employee e)
	{
		ResultDTO result = new ResultDTO();

		int id = (int) employeeService.save(e);
		if(id>0)
		{
			result.setStatusCode(HttpStatus.OK.value());
			result.setStatus("Success");
			result.setMessage("Added Successfully");
			return new ResponseEntity<ResultDTO>(result,HttpStatus.OK);
		}
		else
		{
			result.setStatusCode(HttpStatus.BAD_REQUEST.value());
			result.setStatus("Failure");
			result.setMessage("Mismatch");
			return new ResponseEntity<ResultDTO>(result,HttpStatus.BAD_REQUEST);
		}

	}



	@GetMapping("/employee/{id}")
	public ResponseEntity<ResultDTO> get(@PathVariable("id") int id)	//Response Entity to accompany http response along with return body
	{
		ResultDTO result = new ResultDTO();
		Employee e = employeeService.get(id);
		if(e != null)
		{
			result.setStatusCode(HttpStatus.OK.value());
			result.setStatus("Success");
			result.setMessage("Added Successfully");
			return new ResponseEntity<ResultDTO>(result,HttpStatus.OK);
		}
		else
		{
			result.setStatusCode(HttpStatus.BAD_REQUEST.value());
			result.setStatus("Failure");
			result.setMessage("Mismatch");
			return new ResponseEntity<ResultDTO>(result,HttpStatus.NOT_FOUND);
		}
	}




	@GetMapping(path = "/employee"/*,produces = {"application/xml"}*/)
	public ResponseEntity<?> list()
	{
		List<Employee> result = employeeService.list();
		if(result.isEmpty())
		{
			return ((BodyBuilder)ResponseEntity.noContent()).body("No Employee Found");
		}
		return new ResponseEntity<List<Employee>>(result, HttpStatus.OK);
	}




	@PutMapping("/employee/{id}")
	public ResponseEntity<ResultDTO> update(@PathVariable("id") int id,@RequestBody Employee e)
	{
		ResultDTO result = new ResultDTO();
		String m = employeeService.update(id,e);
		if(m == null)
		{
			result.setStatusCode(HttpStatus.OK.value());
			result.setStatus("Success");
			result.setMessage("Succesfully Updated Employee "+id);
			return new ResponseEntity<ResultDTO>(result,HttpStatus.OK);
		}
		else
		{
			result.setStatusCode(HttpStatus.NOT_FOUND.value());
			result.setStatus("Failure");
			result.setMessage(m);
			return new ResponseEntity<ResultDTO>(result,HttpStatus.NOT_FOUND);
		}

	}





	@DeleteMapping("/employee/{id}")
	public ResponseEntity<?> delete(@PathVariable("id") int id)
	{
		ResultDTO result = new ResultDTO();
		String m = employeeService.delete(id);
		if(m == null)
		{
			result.setStatusCode(HttpStatus.OK.value());
			result.setStatus("Success");
			result.setMessage("Succesfully Deleted Employee "+id);
			return new ResponseEntity<ResultDTO>(result,HttpStatus.OK);
		}
		else
		{
			result.setStatusCode(HttpStatus.NOT_FOUND.value());
			result.setStatus("Failure");
			result.setMessage(m);
			return new ResponseEntity<ResultDTO>(result,HttpStatus.NOT_FOUND);
		}
	}
}
//-------------------------------------------------------------------------------------------------------------------------------

//EmployeeDaoImpl.java

package com.mindtree.dao.daoImpl;

import java.util.List;

import javax.persistence.criteria.CriteriaBuilder;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Root;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.query.Query;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;
import org.springframework.transaction.annotation.Transactional;

import com.mindtree.dao.EmployeeDao;
import com.mindtree.entity.Employee;

@Repository
public class EmployeeDaoImpl implements EmployeeDao{

	@Autowired
	private SessionFactory sessionFactory;
	@Transactional
	public int save(Employee employee)
	{
		sessionFactory.getCurrentSession().save(employee);
		System.out.println(employee.getId());
		return employee.getId();

	}
	public 	Employee get(int id) {
		return sessionFactory.getCurrentSession().get(Employee.class, id);
	}

	public List<Employee> list() {
		Session session = sessionFactory.getCurrentSession();
		CriteriaBuilder cb = session.getCriteriaBuilder();
		CriteriaQuery<Employee> cq = cb.createQuery(Employee.class);
		Root<Employee> root = cq.from(Employee.class);
		cq.select(root);
		Query<Employee> query = session.createQuery(cq);
		return query.getResultList();
	}

	public String update(int id, Employee employee) {
		Session session = sessionFactory.getCurrentSession();
		Employee emp = session.byId(Employee.class).load(id);
		String m = null;
		if(emp!=null)
		{
			emp.setUsername(employee.getUsername());
			emp.setPassword(employee.getPassword());
			emp.setFullname(employee.getFullname());
			emp.setEmail(employee.getEmail());
			emp.setGender(employee.getGender());
			emp.setDob(employee.getDob());
			emp.setSecuQues(employee.getSecuQues());
			emp.setSecuAnswer(employee.getSecuAnswer());
			session.update(emp);
			session.flush();
		}
		else
		{
			m = "Does not Exist";
		}

		return m;
	}
	public String delete(int id) {
		Session session = sessionFactory.getCurrentSession();
		String m = null;
		Employee emp = session.byId(Employee.class).load(id);
		if(emp!=null)
		{
			session.delete(emp);
		}
		else
		{
			m = "Not Found";
		}
		return m;
	}
}
//-------------------------------------------------------------------------------------------------------------------------------

//EmployeeDao.java

package com.mindtree.dao;

import java.util.List;

import com.mindtree.entity.Employee;

public interface EmployeeDao {

	public int save(Employee employee);
	public Employee get(int id);
	public List<Employee> list();
	public String update(int id, Employee employee);
	public String delete(int id);

}
//----------------------------------------------------------------------------------------------------------------------------------

//ResultDTO.java

package com.mindtree.dto;

public class ResultDTO {

	private String Status;
	private int StatusCode;
	private String Message;


	public String getStatus() {
		return Status;
	}
	public void setStatus(String status) {
		Status = status;
	}
	public int getStatusCode() {
		return StatusCode;
	}
	public void setStatusCode(int i) {
		StatusCode = i;
	}
	public String getMessage() {
		return Message;
	}
	public void setMessage(String message) {
		Message = message;
	}


}
//----------------------------------------------------------------------------------------------------------------------------------

//Employee.java

package com.mindtree.entity;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

@Entity
public class Employee {
	@Id
	@GeneratedValue(strategy=GenerationType.IDENTITY)
	int id;
	String username;
	String password;
	String fullname;
	String email;
	String dob;
	String gender;
	String secuQues;
	String secuAnswer;

	public String getUsername() {
		return username;
	}
	public void setUsername(String username) {
		this.username = username;
	}
	public String getPassword() {
		return password;
	}
	public void setPassword(String password) {
		this.password = password;
	}
	public String getFullname() {
		return fullname;
	}
	public void setFullname(String fullname) {
		this.fullname = fullname;
	}
	public String getEmail() {
		return email;
	}
	public void setEmail(String email) {
		this.email = email;
	}
	public String getDob() {
		return dob;
	}
	public void setDob(String dob) {
		this.dob = dob;
	}
	public String getGender() {
		return gender;
	}
	public void setGender(String gender) {
		this.gender = gender;
	}
	public String getSecuQues() {
		return secuQues;
	}
	public void setSecuQues(String secuQues) {
		this.secuQues = secuQues;
	}
	public String getSecuAnswer() {
		return secuAnswer;
	}
	public void setSecuAnswer(String secuAnswer) {
		this.secuAnswer = secuAnswer;
	}
	public int getId() {
		return id;
	}



}
//---------------------------------------------------------------------------------------------------------------------------------

//EmployeeServiceImpl.java

package com.mindtree.service.serviceImpl;

import java.util.ArrayList;
import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import com.mindtree.dao.EmployeeDao;
import com.mindtree.entity.Employee;
import com.mindtree.service.EmployeeService;

@Service
@Transactional
public class EmployeeServiceImpl implements EmployeeService{

	@Autowired
	EmployeeDao dao;

	public int save(Employee em) {
		Employee emp = new Employee();
		emp.setUsername(em.getUsername());
		emp.setPassword(em.getPassword());
		emp.setFullname(em.getFullname());
		emp.setEmail(em.getEmail());
		emp.setGender(em.getGender());
		emp.setDob(em.getDob());
		emp.setSecuQues(em.getSecuQues());
		emp.setSecuAnswer(em.getSecuAnswer());
		int empid = dao.save(emp);
		return empid;
	}

	public Employee get(int id) {
		Employee emp = dao.get(id);
		Employee e = new Employee();
		if(emp != null)
		{
			e.setUsername(emp.getUsername());
			e.setPassword(emp.getPassword());
			e.setFullname(emp.getFullname());
			e.setEmail(emp.getEmail());
			e.setGender(emp.getGender());
			e.setDob(emp.getDob());
			e.setSecuQues(emp.getSecuQues());
			e.setSecuAnswer(emp.getSecuAnswer());
		}
		else
		{
			e = null;
		}
		return e;
	}

	@Transactional
	public List<Employee> list() {
		List<Employee> e = dao.list();
		List<Employee> emp = new ArrayList<Employee>();
		if(!e.isEmpty())
		{
			for(Employee em: e)
			{
				Employee emp1 = new Employee();
				emp1.setUsername(em.getUsername());
				emp1.setPassword(em.getPassword());
				emp1.setFullname(em.getFullname());
				emp1.setEmail(em.getEmail());
				emp1.setGender(em.getGender());
				emp1.setDob(em.getDob());
				emp1.setSecuQues(em.getSecuQues());
				emp1.setSecuAnswer(em.getSecuAnswer());
				emp.add(emp1);
			}
		}
		return emp;
	}

	@Transactional
	public String update(int id, Employee e) {
		String m = dao.update(id, e);
		return m;

	}

	@Transactional
	public String delete(int id) {
		String m = dao.delete(id);
		return m;
	}

}
//---------------------------------------------------------------------------------------------------------------------------------

//EmployeeService.java

package com.mindtree.service;

import java.util.List;

import com.mindtree.entity.Employee;

public interface EmployeeService {

	int save(Employee e);

	Employee get(int id);

	List<Employee> list();

	String update(int id, Employee e);

	String delete(int id);

}
//-------------------------------------------------------------------------------------------------------------------------------

//pom.xml

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.mindtree</groupId>
  <artifactId>Employee</artifactId>
  <packaging>war</packaging>
  <version>0.0.1-SNAPSHOT</version>
  <name>Employee Maven Webapp</name>
  <url>http://maven.apache.org</url>
  <properties>
		<org.springframework.version>5.0.7.RELEASE</org.springframework.version>
		<jackson.databind.version>2.9.5</jackson.databind.version>
		<hibernate.version>5.2.12.Final</hibernate.version>
		<mysql.connector.version>5.1.46</mysql.connector.version>
	</properties>
	<dependencies>

		<!-- Jackson -->
		<dependency>
			<groupId>com.fasterxml.jackson.core</groupId>
			<artifactId>jackson-databind</artifactId>
			<version>${jackson.databind.version}</version>
		</dependency>
		<!-- Spring -->

		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-webmvc</artifactId>
			<version>${org.springframework.version}</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-tx</artifactId>
			<version>${org.springframework.version}</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-orm</artifactId>
			<version>${org.springframework.version}</version>
		</dependency>

		<!-- Hibernate -->
		<dependency>
			<groupId>org.hibernate</groupId>
			<artifactId>hibernate-core</artifactId>
			<version>${hibernate.version}</version>
		</dependency>

		<!-- MySQL -->
		<dependency>
			<groupId>mysql</groupId>
			<artifactId>mysql-connector-java</artifactId>
			<version>${mysql.connector.version}</version>
		</dependency>


		<!-- Servlet -->
		<dependency>
			<groupId>javax.servlet</groupId>
			<artifactId>servlet-api</artifactId>
			<version>2.5</version>
			<scope>provided</scope>
		</dependency>

		<!-- Test -->
		<dependency>
			<groupId>junit</groupId>
			<artifactId>junit</artifactId>
			<version>4.12</version>
			<scope>test</scope>
		</dependency>
	</dependencies>

  <build>
    <finalName>Employee</finalName>
  </build>
</project>
//------------------------------------------------------------------------------------------------------------------------------------