291 lines
11 KiB
Plaintext
Executable File
291 lines
11 KiB
Plaintext
Executable File
package com.fp.general.rules.save;
|
||
|
||
import java.sql.Date;
|
||
import java.text.SimpleDateFormat;
|
||
import java.util.Calendar;
|
||
import java.util.HashMap;
|
||
import java.util.List;
|
||
import java.util.Map;
|
||
|
||
import javax.persistence.Query;
|
||
|
||
import com.fp.common.helper.CalculationBase;
|
||
import com.fp.common.helper.Constant;
|
||
import com.fp.dto.rules.TransactionRule;
|
||
import com.fp.dto.save.SaveRequest;
|
||
import com.fp.general.exception.GeneralException;
|
||
import com.fp.persistence.commondb.PersistenceHelper;
|
||
import com.fp.persistence.commondb.db.DataHelper;
|
||
import com.fp.persistence.commondb.helper.APPDates;
|
||
import com.fp.persistence.pgeneral.date.TgeneAccountingDate;
|
||
import com.fp.persistence.pgeneral.date.TgeneAccountingDateBranch;
|
||
import com.fp.persistence.pgeneral.date.TgeneAccountingDateKey;
|
||
import com.fp.persistence.pgeneral.date.TgeneNotAccountingDay;
|
||
import com.fp.persistence.pgeneral.gene.TgeneBranch;
|
||
import com.fp.persistence.pgeneral.gene.TgeneBranchKey;
|
||
|
||
/**
|
||
* Clase que se encarga de generar las fechas contables para un tiempo
|
||
* determinado
|
||
*
|
||
* @author scastillo
|
||
* @version 2.1
|
||
*/
|
||
public class GenerateAccountingDate extends TransactionRule {
|
||
|
||
/**
|
||
* Map que contiene los datos del request de los dias contables y no
|
||
* contables
|
||
*/
|
||
private Map<Integer, Map<String, Boolean>> mdays = new HashMap<Integer, Map<String, Boolean>>();
|
||
/**
|
||
* Lista de dias no contables por mes.
|
||
*/
|
||
private List<TgeneNotAccountingDay> lnotaccountingdays;
|
||
/**
|
||
* Fecha de inicio de generacion del calendario.
|
||
*/
|
||
private Date initdatedate;
|
||
/**
|
||
* Fecha de finalizacion de genercion del calendario.
|
||
*/
|
||
private Date enddate;
|
||
|
||
/**
|
||
* Metodo que genra las fechas contables
|
||
*
|
||
* @param saveRequest Datos del request original.
|
||
* @return SaveRequest
|
||
* @throws Exception
|
||
*/
|
||
public SaveRequest normalProcess(SaveRequest saveRequest) throws Exception {
|
||
this.fillMapDay(saveRequest);
|
||
lnotaccountingdays = TgeneNotAccountingDay.findAll(PersistenceHelper.getEntityManager());
|
||
enddate = (Date) saveRequest.get("enddate");
|
||
this.processBranches(saveRequest);
|
||
return saveRequest;
|
||
}
|
||
|
||
/**
|
||
* Metodo que genera fechas contables para la sucursal oficina de proceso.
|
||
*
|
||
* @param saveRequest Datos del request original.
|
||
* @throws Exception
|
||
*/
|
||
private void processBranches(SaveRequest saveRequest) throws Exception {
|
||
Integer init = Integer.parseInt(saveRequest.get("branchcodemin").toString());
|
||
Integer end = Integer.parseInt(saveRequest.get("branchcodemax").toString());
|
||
while (init <= end) {
|
||
TgeneBranchKey tgeneBranchKey = new TgeneBranchKey(init, saveRequest.getCompany());
|
||
TgeneBranch tgeneBranch = TgeneBranch.find(PersistenceHelper.getEntityManager(), tgeneBranchKey);
|
||
if (tgeneBranch != null) {
|
||
//Obtiene la fecha de inicio por cada sucursal
|
||
initdatedate = (Date) saveRequest.get("initdate");
|
||
this.delete(init, saveRequest.getCompany());
|
||
this.validateDatesByBranch(init, saveRequest.getCompany());
|
||
this.processByDate(saveRequest, init);
|
||
}
|
||
init++;
|
||
}
|
||
}
|
||
|
||
private void processByDate(SaveRequest saveRequest, Integer pBranch) throws Exception {
|
||
APPDates d = new APPDates(initdatedate, CalculationBase.B365365);
|
||
while (initdatedate.compareTo(enddate) <= 0) {
|
||
this.generateCalendar(saveRequest, pBranch, d);
|
||
d.addField(Calendar.DAY_OF_YEAR, 1);
|
||
initdatedate = d.getDate();
|
||
}
|
||
}
|
||
|
||
/**
|
||
*
|
||
* @param saveRequest Datos del request original.
|
||
* @param pBranch Codigo de sucursal a generar la fecha contable.
|
||
* @param d Fecha real con la cual se obtiene la fecha de trabajo y la
|
||
* contable.
|
||
* @throws Exception
|
||
*/
|
||
private void generateCalendar(SaveRequest saveRequest, Integer pBranch, APPDates d) throws Exception {
|
||
Map<String, Boolean> m = this.mdays.get(d.getField(Calendar.DAY_OF_WEEK));
|
||
TgeneAccountingDateKey key = new TgeneAccountingDateKey();
|
||
key.setCompanycode(saveRequest.getCompany());
|
||
key.setBranchcode(pBranch);
|
||
key.setRealdate(d.getDate());
|
||
TgeneAccountingDate obj = new TgeneAccountingDate();
|
||
obj.setPk(key);
|
||
obj.setAccountingdate(this.getDate(d, "accounting", m));
|
||
obj.setWorkingdate(this.getDate(d, "working", m));
|
||
PersistenceHelper.save(obj);
|
||
}
|
||
|
||
/**
|
||
* Entrega la fecha contable para una fecha real.
|
||
*
|
||
* @param d Fecha real con la cual se obtien la fecha de trabajo y la fecha
|
||
* contable.
|
||
* @param fieldname Nombre del campo, working o accounting
|
||
* @param m Map que contien indica si la fecha es laborable y/o contable.
|
||
* @return Date
|
||
* @throws Exception
|
||
*/
|
||
private Date getDate(APPDates d, String fieldname, Map<String, Boolean> m) throws Exception {
|
||
if (m.get(fieldname)) {
|
||
if (fieldname.compareTo("working") == 0) {
|
||
return d.getDate();
|
||
} else if (this.validateDayOfTheMonth(d)) {
|
||
//Si es fecha contable verifica que el dia dentro del mes sea contable.
|
||
return d.getDate();
|
||
}
|
||
}
|
||
APPDates daux = new APPDates(d.getDate(), CalculationBase.B365365);
|
||
int day = d.getField(Calendar.DAY_OF_WEEK);
|
||
boolean cont = true;
|
||
while (cont) {
|
||
day++;
|
||
if (day == 8) {
|
||
day = 1;
|
||
}
|
||
daux.addField(Calendar.DAY_OF_YEAR, 1);
|
||
if (fieldname.compareTo("accounting") == 0 && !this.validateDayOfTheMonth(daux)) {
|
||
//Si el dia es no contable continua
|
||
continue;
|
||
}
|
||
if (this.mdays.get(day).get(fieldname)) {
|
||
cont = false;
|
||
}
|
||
}
|
||
return daux.getDate();
|
||
}
|
||
|
||
/**
|
||
* Valida si el dia es contable dentro del mes, ejemplo 1 de enero no es
|
||
* contable.
|
||
*
|
||
* @param d Fecha verificar si el dia es contable.
|
||
* @return boolean
|
||
* @throws Exception
|
||
*/
|
||
private boolean validateDayOfTheMonth(APPDates d) throws Exception {
|
||
boolean isaccounting = true;
|
||
String mes = String.valueOf(d.getField(Calendar.MONTH));
|
||
if (mes.length() == 1) {
|
||
mes = "0" + mes;
|
||
}
|
||
for (TgeneNotAccountingDay obj : lnotaccountingdays) {
|
||
if (obj.getPk().getCatalog().compareTo(mes) != 0) {
|
||
continue;
|
||
}
|
||
int day = d.getField(Calendar.DAY_OF_MONTH);
|
||
if (obj.getPk().getDay().compareTo(day) == 0) {
|
||
isaccounting = false;
|
||
break;
|
||
}
|
||
}
|
||
return isaccounting;
|
||
}
|
||
|
||
@SuppressWarnings("unchecked")
|
||
private void fillMapDay(SaveRequest saveRequest) throws Exception {
|
||
List<Object> lobj = saveRequest.getSaveBeanModifiedRecords("LISTACCOUNTINDATE");
|
||
if(lobj == null || lobj.isEmpty()){
|
||
lobj = (List<Object>)saveRequest.get("LISTACCOUNTINDATE");
|
||
}
|
||
boolean isworking = false;
|
||
boolean isaccounting = false;
|
||
|
||
for (Object object : lobj) {
|
||
Map<String, Object> m = (Map<String, Object>) object;
|
||
Integer day = Integer.parseInt(m.get("day").toString());
|
||
String working = m.get("teller").toString();
|
||
String accounting = m.get("accounting").toString();
|
||
Map<String, Boolean> maux = new HashMap<String, Boolean>();
|
||
maux.put("working", Constant.ifYes(working));
|
||
maux.put("accounting", Constant.ifYes(accounting));
|
||
mdays.put(day, maux);
|
||
if(!isworking){
|
||
isworking = Constant.ifYes(working);
|
||
}
|
||
if(!isaccounting){
|
||
isaccounting = Constant.ifYes(accounting);
|
||
}
|
||
}
|
||
if(!isaccounting || !isworking){
|
||
throw new GeneralException("GENE-0052", "INGRESE AL MENOS UN D<>A CONATBLE Y DE TRABAJO PARA GENERAR EL CALENDARIO");
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Sentencia que se encarga de eliminar el calendario de fechas por sucursal
|
||
*/
|
||
private static String DEL = "delete from TgeneAccountingDate t "
|
||
+ " where t.pk.branchcode = :branch "
|
||
+ " and t.pk.companycode = :company "
|
||
+ " and t.pk.realdate >= :datefrom ";
|
||
|
||
/**
|
||
* Elimna fechas del calendario por sucursal y mayor a la fecha a regenerar
|
||
* el calendario.
|
||
*
|
||
* @param pBracnch Codigo de sucursal.
|
||
* @param pCompany Codigo de compania.
|
||
* @throws Exception
|
||
*/
|
||
private void delete(Integer pBracnch, Integer pCompany) throws Exception {
|
||
Query qry = PersistenceHelper.getEntityManager().createQuery(DEL);
|
||
qry.setParameter("branch", pBracnch);
|
||
qry.setParameter("company", pCompany);
|
||
qry.setParameter("datefrom", this.initdatedate);
|
||
qry.executeUpdate();
|
||
}
|
||
/**
|
||
* Sentencia que se encarga de eliminar el calendario de fechas por sucursal
|
||
*/
|
||
private static String SQL_VAL = "select max(t.pk.realdate) from TgeneAccountingDate t "
|
||
+ " where t.pk.branchcode = :branch "
|
||
+ " and t.pk.companycode = :company "
|
||
+ " and t.pk.realdate < :datefrom ";
|
||
|
||
/**
|
||
* Valida que en la generacion de del calendario no exista huecos de fechas
|
||
* realres.
|
||
*
|
||
* @param pBracnch Codigo de sucursal.
|
||
* @param pCompany Codigo de compania.
|
||
* @throws Exception
|
||
*/
|
||
private void validateDatesByBranch(Integer pBracnch, Integer pCompany) throws Exception {
|
||
Query qry = PersistenceHelper.getEntityManager().createQuery(SQL_VAL);
|
||
qry.setParameter("branch", pBracnch);
|
||
qry.setParameter("company", pCompany);
|
||
qry.setParameter("datefrom", this.initdatedate);
|
||
Date d = (Date) qry.getSingleResult();
|
||
if (d == null) {
|
||
return;
|
||
}
|
||
APPDates appd = new APPDates(d, CalculationBase.B365365);
|
||
appd.addField(Calendar.DAY_OF_YEAR, 1);
|
||
if (appd.getDate().compareTo(initdatedate) < 0) {
|
||
SimpleDateFormat fd = new SimpleDateFormat("dd-MM-yyyy");
|
||
throw new GeneralException("GENE-0019", "EL CALENDARIO NO PUEDE DEJAR HUECOS PARA LA SUCURSAL: {0} FCONTABLE ANTERIOR: {1}", pBracnch, fd.format(d));
|
||
}
|
||
TgeneAccountingDateBranch ad = DataHelper.getInstance().getTgeneAccountingDateBranch(pCompany, 0);
|
||
if (ad.getRealdate().compareTo(initdatedate) > 0) {
|
||
throw new GeneralException("GENE-0020", "FECHA DE INICIO PARA GENERAR CALENDARIO NO PUEDE SER MENOR A: {0}",
|
||
ad.getRealdate());
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Metodo que se ejecuta en modo reverso
|
||
*
|
||
* @param saveRequest
|
||
* @return SaveRequest
|
||
* @throws Exception
|
||
*/
|
||
public SaveRequest reverseProcess(SaveRequest saveRequest) throws Exception {
|
||
//En este caso no hacer nada no existen reversos.
|
||
return saveRequest;
|
||
}
|
||
}
|