#  DB Connection Properties
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/REST_INVOICE
spring.datasource.username=root
spring.datasource.password=devs

# JPA Properites
spring.jpa.show-sql=true
spring.jpa.hibernate.ddl-auto=update
spring.jpa.database-platform=org.hibernate.dialect.MySQL8Dialect

package com.dev.invoice.rest.entity;

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

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@NoArgsConstructor
@AllArgsConstructor
@Entity
public class Invoice {
	
	@Id
	@GeneratedValue
	private Long id;
	private String name;
	private Double amount;
	private Double finalAmount;
	private String number;
	private String receivedDate;
	private String type;
	private String vendor;
	private String comments;
}

package com.dev.invoice.rest.repo;

import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Modifying;
import org.springframework.data.jpa.repository.Query;

import com.dev.invoice.rest.entity.Invoice;

public interface InvoiceRepository extends JpaRepository<Invoice, Long>{
	
	// Update is Non-Select Operation, so @Modifying is used
	@Modifying
	@Query("UPDATE Invoice SET number=:number WHERE id=:id")
	Integer updateInvoiceNumberById(String number,Long id);
}

package com.dev.invoice.rest.service;

import java.util.List;

import com.dev.invoice.rest.entity.Invoice;

public interface IInvoiceService {
	
	/**
	 * Takes Invoice Object as input and returns PK generated
	 */
	Long saveInvoice(Invoice inv);
	
	/**
	 * Takes existing Invoice data as input and updates values
	 */
	void updateInvoice(Invoice e);
	
	/**
	 * Takes PK(ID) as input and deletes Invoice Object data
	 */
	void deleteInvoice(Long id);	
	
	/**
	 * Takes id as input and returns one row as one object
	 */
	Invoice getOneInvoice(Long id);  //used in RestController
	
	/**
	 * select all rows and provides result as a List<Invoice>
	 */
	List<Invoice> getAllInvoices();
	
	/**
	 * Takes Id as input,checks if record exists returns true, else false
	 * 
	 */
	boolean isInvoiceExist(Long id);
	
	/**
	 * Takes 2 fields as input, updates Invoice data as provided where clause
	 * like 'UPDATE Invoice SET number=:number WHERE id=:id'
	 */
	Integer updateInvoiceNumberById(String number,Long id);
}

package com.dev.invoice.rest.service.impl;

import java.util.List;
import java.util.Optional;

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

import com.dev.invoice.rest.entity.Invoice;
import com.dev.invoice.rest.exception.InvoiceNotFoundException;
import com.dev.invoice.rest.repo.InvoiceRepository;
import com.dev.invoice.rest.service.</yoastmark>IInvoiceService;
import com.dev.invoice.rest.util.InvoiceUtil;

@Service 
public class InvoiceServiceImpl implements IInvoiceService {
	
	@Autowired
	private InvoiceRepository repo;  
	
	@Autowired
	private InvoiceUtil util;
	
	@Override
	public Long saveInvoice(Invoice inv) {
		util.CalculateFinalAmountIncludingGST(inv);
		Long id = repo.save(inv).getId();
		return id;
	}

	@Override
	public void updateInvoice(Invoice inv) {
		util.CalculateFinalAmountIncludingGST(inv);
		repo.save(inv);
	}

	@Override
	public void deleteInvoice(Long id) {
		Invoice inv= getOneInvoice(id);
		repo.delete(inv);
	}
	
	public Optional<Invoice> getSingleInvoice(Long Id) {
		return repo.findById(Id);
	}

	@Override
	public Invoice getOneInvoice(Long id) {

		Invoice inv = repo.findById(id)
				.orElseThrow(()->new InvoiceNotFoundException(
						new StringBuffer().append("Product  '")
						.append(id)
						.append("' not exist")
						.toString())
						);
		return inv;
	}

	@Override
	public List<Invoice> getAllInvoices() {
		List<Invoice> list = repo.findAll();
		//JDK 1.8 List Sort (using Comparator)
				list.sort((ob1,ob2)->ob1.getId().intValue()-ob2.getId().intValue());
				//list.sort((ob1,ob2)->ob1.getAmount().compareTo(ob2.getAmount())); //ASC
				//list.sort((ob1,ob2)->ob2.getAmount().compareTo(ob1.getAmount())); // DESC
		return list;
	}
	
	@Override
	public boolean isInvoiceExist(Long id) {
		
		return repo.existsById(id);
	}
	
	@Override
	@Transactional
	public Integer updateInvoiceNumberById(
			String number, Long id) 
	{
		if(!repo.existsById(id)) { 
			throw new InvoiceNotFoundException(
					new StringBuffer()
					.append("Invoice '")
					.append(id)
					.append("' not exist")
					.toString());
		}
		return repo.updateInvoiceNumberById(number, id);
	}
	
}

package com.dev.invoice.rest.entity;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@NoArgsConstructor
@AllArgsConstructor
public class ErrorType {

	private String time;
	private String status;
	private String message;
	
}

package com.dev.invoice.rest.exception;

//Custom Exception
public class InvoiceNotFoundException extends RuntimeException{

	private static final long serialVersionUID = 1L;

	public InvoiceNotFoundException() {
		super();
	}
	
	public InvoiceNotFoundException(String message) {
		super(message);
	}
	
}

package com.dev.invoice.rest.exception.handler;

import java.util.Date;

import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.RestControllerAdvice;

import com.dev.invoice.rest.entity.ErrorType;
import com.dev.invoice.rest.exception.InvoiceNotFoundException;

//@ControllerAdvice
@RestControllerAdvice
public class InvoiceErrorHandler {
	/**
	 * In case of InvoiceNotFoundException is thrown
	 * from any controller method, this logic gets
	 * executed which behaves like re-usable and
	 * clear code (Code Modularity)
	 * @param nfe
	 * @return ResponseEntity
	 */
	//@ResponseBody
	@ExceptionHandler(InvoiceNotFoundException.class)
	public ResponseEntity<ErrorType> handleNotFound(InvoiceNotFoundException nfe){
		
		return new ResponseEntity<ErrorType>(
				new ErrorType(
						new Date(System.currentTimeMillis()).toString(), 
						"404- NOT FOUND", 
						nfe.getMessage()), 
				HttpStatus.</yoastmark>NOT_FOUND);
	}
}

package com.dev.invoice.rest.util;

import org.springframework.stereotype.Component;

import com.dev.invoice.rest.entity.Invoice;

@Component
public class InvoiceUtil {
	
	public Invoice  CalculateFinalAmountIncludingGST (Invoice inv) {
		var amount=inv.getAmount();
		var gst= 0.1;
		var finalAmount=amount+(amount*gst);
		inv.setFinalAmount(finalAmount);
		return inv;
	}
	
	public void copyNonNullValues(Invoice req, Invoice db) {
		
		if(req.getName() !=null) {
			db.setName(req.getName());
		}
		
		if(req.getAmount() !=null) {
			db.setAmount(req.getAmount());
		}
		
		if(req.getNumber() !=null) {
			db.setNumber(req.getNumber());
		}
		
		if(req.getReceivedDate() !=null) {
			db.setReceivedDate(req.getReceivedDate());
		}
		
		if(req.getType() !=null) {
			db.setType(req.getType());
		}
		
		if(req.getVendor() !=null) {
			db.setVendor(req.getVendor());
		}
		
		if(req.getComments() !=null) {
			db.setComments(req.getComments());
		}
	}
}

package com.dev.invoice.rest.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.web.bind.annotation.CrossOrigin;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PatchMapping;
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.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import com.dev.invoice.rest.entity.Invoice;
import com.dev.invoice.rest.exception.InvoiceNotFoundException;
import com.dev.invoice.rest.service.IInvoiceService;
import com.dev.invoice.rest.util.InvoiceUtil;

@RestController
@RequestMapping("/api")
// @CrossOrigin(origins = "http://localhost:4200") //Required in case of Angular Client
public class InvoiceRestController {
	
	@Autowired
	private IInvoiceService service;  
	
	@Autowired
	private InvoiceUtil util;
	
	/**
	 * Takes Invoice Object as input and returns save Status as ResponseEntity<String>
	 */
	@PostMapping("/invoices")
	public ResponseEntity<String> saveInvoice(@RequestBody Invoice inv){
		ResponseEntity<String> resp = null;
		try{
			Long id = service.saveInvoice(inv);
			resp= new ResponseEntity<String>(
					"Invoice '"+id+"' created",HttpStatus.CREATED); //201-created
		} catch (Exception e) {
			e.printStackTrace();
			resp = new ResponseEntity<String>(
					"Unable to save Invoice", 
					HttpStatus.INTERNAL_SERVER_ERROR); //500-Internal Server Error
		}
		return resp;
	}
	
	/**
	 * To retrieve all Invoices, returns data retrieval Status as ResponseEntity<?>
	 */
	@GetMapping("/invoices")
	public ResponseEntity<?> getAllInvoices() {
		ResponseEntity<?> resp=null;
		try {
			List<Invoice> list= service.getAllInvoices();
			resp= new ResponseEntity<List<Invoice>>(list,HttpStatus.OK);
		} catch (Exception e) {
			e.printStackTrace();
			resp = new ResponseEntity<String>(
					"Unable to get Invoice", 
					HttpStatus.INTERNAL_SERVER_ERROR);
		}
		return resp;
	}
	
	/**
	 * To retrieve one Invoice by providing id, returns Invoice object & Status as ResponseEntity<?>
	 */
	@GetMapping("/invoices/{id}")
	public ResponseEntity<?> getOneInvoice(@PathVariable Long id){
		ResponseEntity<?> resp= null;
		try {
			Invoice inv= service.getOneInvoice(id);
			resp= new ResponseEntity<Invoice>(inv,HttpStatus.OK);
		}catch (InvoiceNotFoundException nfe) {
			throw nfe; 
		}catch (Exception e) {
			e.printStackTrace();
			resp = new ResponseEntity<String>(
					"Unable to find Invoice", 
					HttpStatus.INTERNAL_SERVER_ERROR);
		}
		return resp;
	}
	
	/**
	 * To delete one Invoice by providing id, returns Status as ResponseEntity<String>
	 */
	@DeleteMapping("/invoices/{id}")
	public ResponseEntity<String> deleteInvoice(@PathVariable Long id){
		
		ResponseEntity<String> resp= null;
		try {
			service.deleteInvoice(id);
			resp= new ResponseEntity<String> (
					"Invoice '"+id+"' deleted",HttpStatus.OK);
			
		} catch (InvoiceNotFoundException nfe) {
			throw nfe;
		} catch (Exception e) {
			e.printStackTrace();
			resp= new ResponseEntity<String>(
					"Unable to delete Invoice", HttpStatus.INTERNAL_SERVER_ERROR);
		}
		
		return resp;
	}
	
	/**
	 * To modify one Invoice by providing id, updates Invoice object & returns Status as ResponseEntity<String>
	 */
	@PutMapping("/invoices/{id}")
	public ResponseEntity<String> updateInvoice(@PathVariable Long id, @RequestBody Invoice invoice){
		
		ResponseEntity<String> resp = null;
		try {
			//db Object
			Invoice inv= service.getOneInvoice(id);
			//copy non-null values from request to Database object
			util.copyNonNullValues(invoice, inv);
			//finally update this object
			service.updateInvoice(inv);
			resp = new ResponseEntity<String>(
					//"Invoice '"+id+"' Updated",
					HttpStatus.RESET_CONTENT); //205- Reset-Content(PUT)
			
		} catch (InvoiceNotFoundException nfe) {
			throw nfe; // re-throw exception to handler
		} catch (Exception e) {
			e.printStackTrace();
			resp = new ResponseEntity<String>(
					"Unable to Update Invoice", 
					HttpStatus.INTERNAL_SERVER_ERROR); //500-ISE
		}
		return resp;
	}
	
	/**
	 * To update one Invoice just like where clause condition, updates Invoice object & returns Status as ResponseEntity<String>
	 */
	@PatchMapping("/invoices/{id}/{number}")
	public ResponseEntity<String> updateInvoiceNumberById(
			@PathVariable Long id,
			@PathVariable String number
			) 
	{
		ResponseEntity<String> resp = null;
		try {
			service.updateInvoiceNumberById(number, id);
			resp = new ResponseEntity<String>(
					"Invoice '"+number+"' Updated",
					HttpStatus.PARTIAL_CONTENT); //206- Reset-Content(PUT)
			
		} catch(InvoiceNotFoundException pne) {
			throw pne; // re-throw exception to handler
		} catch (Exception e) {
			e.printStackTrace();
			resp = new ResponseEntity<String>(
					"Unable to Update Invoice", 
					HttpStatus.INTERNAL_SERVER_ERROR); //500-ISE
		}
		return resp;
	}
}