ReceptionService.java

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package com.github.adminfaces.starter.service;

import com.github.adminfaces.starter.bean.AccTypesFormMB;
import com.github.adminfaces.starter.infra.model.Filter;
import com.github.adminfaces.starter.infra.model.SortOrder;
import com.github.adminfaces.starter.infra.security.LogonMB;
//import com.github.adminfaces.starter.infra.security.LogonMB;
import com.github.adminfaces.starter.model.Reception;
import com.github.adminfaces.starter.util.Db;
import com.github.adminfaces.template.config.AdminConfig;
import com.github.adminfaces.template.exception.BusinessException;

import javax.ejb.Stateless;
import javax.inject.Inject;

import org.apache.log4j.Logger;

import java.io.Serializable;
import java.net.Inet4Address;
import java.net.UnknownHostException;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.function.Predicate;
import java.util.stream.Collectors;

import static com.github.adminfaces.template.util.Assert.has;

/**
 * @author rmpestano
 *         Reception Business logic
 */
@Stateless
public class ReceptionService implements Serializable {

	 @Inject
	    List<Reception> allPatients;
	    @Inject
	    private LogonMB logonMB;
	    protected PreparedStatement ps;
	    protected Statement stmt;
		protected ResultSet rs;
		private static Logger logger = Logger.getLogger(ReceptionService.class);
		
		public String CurrentTime() {
	        return new SimpleDateFormat("yyyy.MM.dd.HH.mm.ss").format(new Date());
	    }	
    public List<Reception> listByModel(String names) {
        return allPatients.stream()
                .filter(c -> c.getNames().equalsIgnoreCase(names))
                .collect(Collectors.toList());

    }

    public List<Reception> paginate(Filter<Reception> filter) {
        List<Reception> pagedPatients = new ArrayList<>();
        if(has(filter.getSortOrder()) && !SortOrder.UNSORTED.equals(filter.getSortOrder())) {
                pagedPatients = allPatients.stream().
                    sorted((c1, c2) -> {
                        if (filter.getSortOrder().isAscending()) {
                            return c1.getOpno().compareTo(c2.getOpno());
                        } else {
                            return c2.getOpno().compareTo(c1.getOpno());
                        }
                    })
                    .collect(Collectors.toList());
            }

        int page = filter.getFirst() + filter.getPageSize();
        if (filter.getParams().isEmpty()) {
            pagedPatients = pagedPatients.subList(filter.getFirst(), page > allPatients.size() ? allPatients.size() : page);
            return pagedPatients;
        }

        List<Predicate<Reception>> predicates = configFilter(filter);

        List<Reception> pagedList = allPatients.stream().filter(predicates
                .stream().reduce(Predicate::or).orElse(t -> true))
                .collect(Collectors.toList());

        if (page < pagedList.size()) {
            pagedList = pagedList.subList(filter.getFirst(), page);
        }

        if (has(filter.getSortField())) {
            pagedList = pagedList.stream().
                    sorted((c1, c2) -> {
                        boolean asc = SortOrder.ASCENDING.equals(filter.getSortOrder());
                        if (asc) {
                            return c1.getOpno().compareTo(c2.getOpno());
                        } else {
                            return c2.getOpno().compareTo(c1.getOpno());
                        }
                    })
                    .collect(Collectors.toList());
        }
        return pagedList;
    }

    private List<Predicate<Reception>> configFilter(Filter<Reception> filter) {
        List<Predicate<Reception>> predicates = new ArrayList<>();
        if (filter.hasParam("id")) {
            Predicate<Reception> idPredicate = (Reception c) -> c.getOpno().equals(filter.getParam("id"));
            predicates.add(idPredicate);
        }

        if (has(filter.getEntity())) {
            Reception filterEntity = filter.getEntity();
            if (has(filterEntity.getOpno())) {
                Predicate<Reception> opnoPredicate = (Reception c) -> c.getOpno().equals(filterEntity.getOpno());
                predicates.add(opnoPredicate);
            }
            
            if (has(filterEntity.getNames())) {
                Predicate<Reception> namesPredicate = (Reception c) -> c.getNames().toLowerCase().contains(filterEntity.getNames().toLowerCase());
                predicates.add(namesPredicate);
            }
            
        }
        return predicates;
    }
    
    public List<String> getOpno(String query) {
        return allPatients.stream().filter(c -> c.getOpno()
                .toLowerCase().contains(query.toLowerCase()))
                .map(Reception::getOpno)
                .collect(Collectors.toList());
    }

    public List<String> getNames(String query) {
        return allPatients.stream().filter(c -> c.getNames()
                .toLowerCase().contains(query.toLowerCase()))
                .map(Reception::getNames)
                .collect(Collectors.toList());
    }

   
    public void insert(Reception reception) {    	
        validate(reception);
        Db.connect();
		try {
			String IP = Inet4Address.getLocalHost().getHostAddress();	
			String acctypename = reception.getNames();
			int userid= logonMB.getCurrentUserId();
			
			logger.info(CurrentTime() + "|" + "Create New User Account Type Process" + "|" + "INFO" + "|" + "Processing - Create New User Account Type " +
			"|" + acctypename + " |" + userid + "|" + IP + "|" + "jdbc:mysql://localhost/temis" + "|" + "Begin Creating User Account Type");
			
			String sql = "INSERT INTO `tbl_temis_account_types`(name,date_created,created_by) VALUES (?,?,?)";
			ps= Db.conn.prepareStatement(sql);			
			ps.setString(1, acctypename);//names
            ps.setTimestamp(2, Db.getCurrentTimeStamp());
            ps.setInt(3, userid);//received_by
			int i = ps.executeUpdate();
			//logger.error("reception.getNames()"+reception.getNames()+"reception.getNames()");
			allPatients.add(reception);
			
			logger.info(CurrentTime() + "|" + "Create New User Account Type Process" + "|" + "INFO" + "|" + "Finished - Create New User Account Type " +
					"|" + acctypename + " |" + userid + "|" + IP + "|" + "jdbc:mysql://localhost/temis" + "|" + "Finished Creating User Account Type");
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
			logger.error(e.getMessage());
		} 		
		Db.disconnect();
    }

    public void validate(Reception reception) {
        BusinessException be = new BusinessException();      
        if (!has(reception.getNames())) {
            be.addException(new BusinessException("Patient Name Cannot be empty"));
        }
        if (allPatients.stream().filter(c -> c.getNames().equalsIgnoreCase(reception.getNames())
                && c.getNames() != c.getNames()).count() > 0) {
            be.addException(new BusinessException("Patient name must be unique"));
        }
        if(has(be.getExceptionList())) {
            throw be;
        }
    }
    
    public int deletePatient(Reception reception)
	{
    	Db.connect();
		int ret = 0;
		try {
		String IP = Inet4Address.getLocalHost().getHostAddress();	
		String acctypename = reception.getNames();
		int tid = Integer.valueOf(reception.getOpno());
		int userid= logonMB.getCurrentUserId();
		
		logger.info(CurrentTime() + "|" + "Delete User Account Type Process" + "|" + "INFO" + "|" + "Processing - Delete User Account Type " +
		"|" + acctypename + " |" + userid + "|" + IP + "|" + "jdbc:mysql://localhost/temis" + "|" + "Begin Deleting User Account Type");
		
		String sqldelete = "DELETE FROM tbl_temis_account_types WHERE tid= "+tid;		
		logger.error("sqldelete"+sqldelete);
		stmt = Db.conn.createStatement();
		stmt.executeUpdate(sqldelete);
		
		logger.info(CurrentTime() + "|" + "Delete User Account Type Process" + "|" + "INFO" + "|" + "Finished - Delete User Account Type " +
					"|" + acctypename + " |" + userid + "|" + IP + "|" + "jdbc:mysql://localhost/temis" + "|" + "Finished Delete User Account Type");
		} catch (Exception e) {
			// TODO Auto-generated catch block
			ret = 1;
			e.printStackTrace();
			logger.error(e.getStackTrace());
		} 		
		Db.disconnect();
		return ret;
	}	

    public void remove(Reception reception) { 
    	deletePatient(reception);
        allPatients.remove(reception);
    }

    public long count(Filter<Reception> filter) {
        return allPatients.stream()
                .filter(configFilter(filter).stream()
                        .reduce(Predicate::or).orElse(t -> true))
                .count();
    }

    public Reception findByOpno(String opno) {
        return allPatients.stream()
                .filter(c -> c.getOpno().equals(opno))
                .findFirst()
                .orElseThrow(() -> new BusinessException("Patient not found with patient code# " + opno));
    }

    public void update(Reception reception) {
        validate(reception);
        allPatients.remove(allPatients.indexOf(reception));
        allPatients.add(reception);
    }
}