Example usage for org.hibernate.criterion Restrictions between

List of usage examples for org.hibernate.criterion Restrictions between

  1. HOME
  2. Java
  3. org.hibernate
  4. org.hibernate.criterion.*
  5. Restrictions
  6. between

Introduction

In this page you can find the example usage for org.hibernate.criterion Restrictions between.

Prototype

public static Criterion between(String propertyName, Object low, Object high)

Source Link

Document

Apply a "between" constraint to the named property

Usage

From source file:es.sm2.openppm.core.dao.TeamMemberDAO.java

License:Open Source License

/**
 * Search Team Members by Project with actuals FTEs
 * //from  ww  w . j  a  v  a 2s.  c om
 * @param project
 * @param since
 * @param until
 * @return
 */
public List<Teammember> consStaffinActualsFtes(Project project, Date since, Date until) {

    Criteria crit = getSession().createCriteria(getPersistentClass())
            .setResultTransformer(Criteria.DISTINCT_ROOT_ENTITY)
            .add(Restrictions.eq(Teammember.STATUS, Constants.RESOURCE_ASSIGNED))
            .add(Restrictions.disjunction().add(Restrictions.between(Teammember.DATEIN, since, until))
                    .add(Restrictions.between(Teammember.DATEOUT, since, until))
                    .add(Restrictions.and(Restrictions.le(Teammember.DATEIN, since),
                            Restrictions.ge(Teammember.DATEOUT, until))));

    crit.createCriteria(Teammember.PROJECTACTIVITY).add(Restrictions.eq(Projectactivity.PROJECT, project));

    Criteria timesheetsCrit = crit.createCriteria(Teammember.EMPLOYEE).createCriteria(Employee.TIMESHEETS)
            .add(Restrictions.eq(Timesheet.STATUS, Constants.TIMESTATUS_APP3))
            .add(Restrictions.disjunction().add(Restrictions.between(Timesheet.INITDATE, since, until))
                    .add(Restrictions.between(Timesheet.ENDDATE, since, until))
                    .add(Restrictions.and(Restrictions.le(Timesheet.INITDATE, since),
                            Restrictions.ge(Timesheet.ENDDATE, until))));

    timesheetsCrit.createCriteria(Timesheet.PROJECTACTIVITY)
            .add(Restrictions.eq(Projectactivity.PROJECT, project));

    crit.setFetchMode(Teammember.JOBCATEGORY, FetchMode.JOIN);
    crit.setFetchMode(Teammember.EMPLOYEE, FetchMode.JOIN);
    crit.setFetchMode(Teammember.EMPLOYEE + "." + Employee.CALENDARBASE, FetchMode.JOIN);

    return crit.list();
}

From source file:es.sm2.openppm.core.dao.TeamMemberDAO.java

License:Open Source License

/**
 * Check if resource is assigned in range of dates in activity 
 * /*from   w  ww .  j  av a  2 s .c o m*/
 * @param member
 * @return
 */
public boolean isAssigned(Teammember member) {

    Date since = member.getDateIn();
    Date until = member.getDateOut();

    Criteria crit = getSession().createCriteria(getPersistentClass()).setProjection(Projections.rowCount())
            .add(Restrictions.eq(Teammember.PROJECTACTIVITY, member.getProjectactivity()))
            .add(Restrictions.eq(Teammember.EMPLOYEE, member.getEmployee()))
            .add(Restrictions.ne(Teammember.STATUS, Constants.RESOURCE_RELEASED))
            .add(Restrictions.disjunction().add(Restrictions.between(Teammember.DATEIN, since, until))
                    .add(Restrictions.between(Teammember.DATEOUT, since, until))
                    .add(Restrictions.and(Restrictions.le(Teammember.DATEIN, since),
                            Restrictions.ge(Teammember.DATEOUT, until))));

    return ((Integer) crit.uniqueResult()) > 0;
}

From source file:es.sm2.openppm.core.dao.TeamMemberDAO.java

License:Open Source License

/**
 * Apply filters by table utility/*from   w ww .jav  a  2  s .co  m*/
 * 
 * @param crit
 * @param filtrosExtras
 * @param orders
 * @param listResourcepool
 * @throws ParseException
 */
private void applyFilters(Criteria crit, List<DatoColumna> filtrosExtras, List<DatoColumna> orders,
        List<Resourcepool> listResourcepool) throws ParseException {

    employeeCrit = crit.createCriteria(Teammember.EMPLOYEE);

    if (ValidateUtil.isNotNull(listResourcepool)) {
        employeeCrit.add(Restrictions.in(Employee.RESOURCEPOOL, listResourcepool));
    }

    critContact = employeeCrit.createCriteria(Employee.CONTACT);
    critActivity = crit.createCriteria(Teammember.PROJECTACTIVITY);
    critProject = critActivity.createCriteria(Projectactivity.PROJECT);

    for (DatoColumna filtroColumna : filtrosExtras) {

        if (filtroColumna.getTipo() == List.class) {

            // Since Until
            if (filtroColumna.getSubTipo() != null && filtroColumna.getSubTipo() == Date.class) {

                Date sinceDate = (Date) filtroColumna.getObjectList()[0];
                Date untilDate = (Date) filtroColumna.getObjectList()[1];

                String sinceName = (String) filtroColumna.getNombreList()[0];
                String untilName = (String) filtroColumna.getNombreList()[1];

                crit.add(Restrictions.disjunction().add(Restrictions.between(sinceName, sinceDate, untilDate))
                        .add(Restrictions.between(untilName, sinceDate, untilDate)).add(Restrictions.and(
                                Restrictions.le(sinceName, sinceDate), Restrictions.ge(untilName, untilDate))));
            } else {
                // Tiene que estar en la lista
                crit.add(Restrictions.in(filtroColumna.getNombre(), filtroColumna.getValorList()));
            }
        } else if (filtroColumna.getTipo() == String.class) {

            if (filtroColumna.getSubTipo() == List.class) {

                if (!ValidateUtil.isNull(filtroColumna.getValor())) {
                    String[] value = filtroColumna.getValor().split(",");
                    List<Integer> ids = new ArrayList<Integer>();

                    for (String id : value) {
                        ids.add(Integer.parseInt(id));
                    }

                    if (filtroColumna.getNombre().equals(Project.EMPLOYEEBYPROJECTMANAGER)) {

                        critProject.add(Restrictions.in(filtroColumna.getNombre() + ".idEmployee", ids));
                    } else if (filtroColumna.getCriteria() != null) {
                        Criteria crit2 = crit.createCriteria(filtroColumna.getCriteria());
                        crit2.add(Restrictions.in(filtroColumna.getNombre(), ids));
                    } else {
                        crit.add(Restrictions.in(filtroColumna.getNombre(), ids));
                    }

                }
            } else {
                // Add filters for fullname project name or charlabel
                if (filtroColumna.getNombre().equals(Contact.FULLNAME)) {

                    critContact.add(
                            Restrictions.like(filtroColumna.getNombre(), "%" + filtroColumna.getValor() + "%"));
                } else if (filtroColumna.getNombre().equals(Configurations.PROJECT_NAME)) {
                    // Filter employees by project description OR project short name
                    critProject.add(Restrictions.disjunction()
                            .add(Restrictions.like(Project.PROJECTNAME,
                                    StringPool.PERCENT + filtroColumna.getValor() + StringPool.PERCENT))
                            .add(Restrictions.like(Project.CHARTLABEL,
                                    StringPool.PERCENT + filtroColumna.getValor() + StringPool.PERCENT)));

                } else {
                    // Comparando texto
                    crit.add(
                            Restrictions.like(filtroColumna.getNombre(), "%" + filtroColumna.getValor() + "%"));
                }
            }
        } else if (filtroColumna.getTipo() == Integer.class) {
            // Filtrando Objectos

            Integer value = Integer.parseInt(filtroColumna.getValor());
            crit.add(Restrictions.eq(filtroColumna.getNombre(), value));
        } else if (filtroColumna.getTipo() != Date.class) {
            // Filtrando Objectos
            if (filtroColumna.getCriteria() != null) {

                crit.createCriteria(filtroColumna.getCriteria())
                        .add(Restrictions.eq(filtroColumna.getNombre(), filtroColumna.getObject()));
            } else {

                crit.add(Restrictions.eq(filtroColumna.getNombre(), filtroColumna.getObject()));
            }
        }
    }
    if (orders != null && !orders.isEmpty()) {

        appplyOrders(crit, orders);
    }
}

From source file:es.sm2.openppm.core.dao.TeamMemberDAO.java

License:Open Source License

/**
 * Find members assigned by project in dates 
 * /*from   ww w  .j a  v  a  2s.c o  m*/
 * @param employee
 * @param joins
 * @return
 * @throws Exception
 */
public List<Teammember> findByEmployeeOrderByProject(Employee employee, Date since, Date until,
        List<String> joins) throws Exception {

    Criteria crit = getSession().createCriteria(getPersistentClass());

    addJoins(crit, joins);
    crit.add(Restrictions.eq(Teammember.EMPLOYEE, employee))
            .add(Restrictions.eq(Teammember.STATUS, Constants.RESOURCE_ASSIGNED));

    if (since != null && until != null) {

        crit.add(Restrictions.disjunction().add(Restrictions.between(Teammember.DATEIN, since, until))
                .add(Restrictions.between(Teammember.DATEOUT, since, until))
                .add(Restrictions.and(Restrictions.le(Teammember.DATEIN, since),
                        Restrictions.ge(Teammember.DATEOUT, until))));
    } else if (since != null) {
        crit.add(Restrictions.and(Restrictions.le(Teammember.DATEIN, since),
                Restrictions.ge(Teammember.DATEOUT, since)));
    } else if (until != null) {
        crit.add(Restrictions.and(Restrictions.le(Teammember.DATEIN, until),
                Restrictions.ge(Teammember.DATEOUT, until)));
    }

    crit.createCriteria(Teammember.PROJECTACTIVITY).createCriteria(Projectactivity.PROJECT)
            .addOrder(Order.desc(Project.IDPROJECT));

    return crit.list();
}

From source file:es.sm2.openppm.core.dao.TeamMemberDAO.java

License:Open Source License

/**
 * Search Team Members by filter/* w ww  .j a v  a 2s  . c  o m*/
 * 
 * @param idResourcePools 
 * @param idProjects
 * @param idPMs
 * @param idJobCategories
 * @param statusList
 * @param fullName
 * @param since
 * @param until
 * @param nameOrder 
 * @param order
 * @param idEmployee 
 * @param user 
 * @param idSellers 
 * @param idCategories 
 * @param settings 
 * @return
 */
public List<Teammember> consStaffinFtes(Integer[] idResourcePools, Integer[] idProjects, Integer[] idPMs,
        Integer[] idJobCategories, String[] statusList, String fullName, Date since, Date until,
        String nameOrder, String order, Integer idEmployee, Employee user, Integer[] idSellers,
        Integer[] idCategories, HashMap<String, String> settings) {

    Criteria crit = getSession().createCriteria(getPersistentClass(), "t");

    if (nameOrder == null && ValidateUtil.isNull(idJobCategories)) {

        crit.add(Restrictions.isNull(Teammember.JOBCATEGORY));
    }

    Criteria projActCrit = crit.createCriteria(Teammember.PROJECTACTIVITY);

    // Filter by sellers
    if (ValidateUtil.isNotNull(idSellers)) {

        projActCrit.createCriteria(Projectactivity.ACTIVITYSELLERS).createCriteria(Activityseller.SELLER)
                .add(Restrictions.in(Seller.IDSELLER, idSellers));
    }

    Criteria projCrit = projActCrit.createCriteria(Projectactivity.PROJECT);

    // Filter by category
    if (ValidateUtil.isNotNull(idCategories)) {

        projCrit.createCriteria(Project.CATEGORY).add(Restrictions.in(Category.IDCATEGORY, idCategories));
    }

    // Filter by Project
    if (ValidateUtil.isNotNull(idProjects)) {
        projCrit.add(Restrictions.in(Project.IDPROJECT, idProjects));
    }

    // Remove information if project is closed
    if (!SettingUtil.getBoolean(settings, SettingType.CLOSED_PROJECTS_CAPACITY_PLANNING)) {
        projCrit.add(Restrictions.and(Restrictions.ne(Project.STATUS, Constants.STATUS_CLOSED),
                Restrictions.ne(Project.STATUS, Constants.STATUS_ARCHIVED)));
    }

    // Filter by Project Manager
    if (user.getResourceprofiles().getIdProfile() == Constants.ROLE_PM) {

        projCrit.createCriteria(Project.EMPLOYEEBYPROJECTMANAGER)
                .add(Restrictions.eq(Employee.IDEMPLOYEE, user.getIdEmployee()));
    } else if (user.getResourceprofiles().getIdProfile() != Constants.ROLE_PM
            && ValidateUtil.isNotNull(idPMs)) {

        projCrit.createCriteria(Project.EMPLOYEEBYPROJECTMANAGER)
                .add(Restrictions.in(Employee.IDEMPLOYEE, idPMs));
    }

    // Filter by Status
    if (ValidateUtil.isNotNull(statusList)) {
        crit.add(Restrictions.in(Teammember.STATUS, statusList));
    }

    // Filter by Skill
    Criteria jobCrit = null;
    if (Jobcategory.IDJOBCATEGORY.equals(nameOrder) || ValidateUtil.isNotNull(idJobCategories)) {
        jobCrit = crit.createCriteria(Teammember.JOBCATEGORY);
    }
    if (ValidateUtil.isNotNull(idJobCategories)) {
        jobCrit.add(Restrictions.in(Jobcategory.IDJOBCATEGORY, idJobCategories));
    }

    // Filter by dates (since && until)
    if (since != null && until != null) {

        crit.add(Restrictions.disjunction().add(Restrictions.between(Teammember.DATEIN, since, until))
                .add(Restrictions.between(Teammember.DATEOUT, since, until))
                .add(Restrictions.and(Restrictions.le(Teammember.DATEIN, since),
                        Restrictions.ge(Teammember.DATEOUT, until))));
    } else if (since != null) {
        crit.add(Restrictions.and(Restrictions.le(Teammember.DATEIN, since),
                Restrictions.ge(Teammember.DATEOUT, since)));
    } else if (until != null) {
        crit.add(Restrictions.and(Restrictions.le(Teammember.DATEIN, until),
                Restrictions.ge(Teammember.DATEOUT, until)));
    }

    // Filter By Employee
    Criteria employeeCrit = crit.createCriteria(Teammember.EMPLOYEE);

    if (idEmployee != null) {
        employeeCrit.add(Restrictions.idEq(idEmployee));
    }

    // Filter by resource pool
    if (ValidateUtil.isNotNull(idResourcePools)) {

        employeeCrit.createCriteria(Employee.RESOURCEPOOL)
                .add(Restrictions.in(Resourcepool.IDRESOURCEPOOL, idResourcePools));
    }

    // Filter by po
    if (user != null) {
        employeeCrit.add(Restrictions.eq(Employee.PERFORMINGORG, user.getPerformingorg()));
    }

    // Filter by Full Name
    Criteria contactCrit = employeeCrit.createCriteria(Employee.CONTACT);
    if (ValidateUtil.isNotNull(fullName)) {
        contactCrit.add(Restrictions.ilike(Contact.FULLNAME, "%" + fullName + "%"));
    }

    // Apply Order
    Criteria orderCrit = null;
    if (Project.IDPROJECT.equals(nameOrder)) {
        orderCrit = projCrit;
    } else if (Jobcategory.IDJOBCATEGORY.equals(nameOrder)) {
        orderCrit = jobCrit;
    } else {
        orderCrit = contactCrit;
    }

    if (nameOrder != null) {
        if (Constants.DESCENDENT.equals(order)) {
            orderCrit.addOrder(Order.desc(nameOrder));
        } else {
            orderCrit.addOrder(Order.asc(nameOrder));
        }
    }

    contactCrit.addOrder(Order.asc(Contact.IDCONTACT));

    List<String> joins = new ArrayList<String>();
    joins.add(Teammember.PROJECTACTIVITY);
    joins.add(Teammember.PROJECTACTIVITY + "." + Projectactivity.PROJECT);
    joins.add(Teammember.PROJECTACTIVITY + "." + Projectactivity.PROJECT + "."
            + Project.EMPLOYEEBYPROJECTMANAGER);
    joins.add(Teammember.PROJECTACTIVITY + "." + Projectactivity.PROJECT + "."
            + Project.EMPLOYEEBYPROJECTMANAGER + "." + Employee.CONTACT);

    addJoins(crit, joins);

    return crit.list();
}

From source file:es.sm2.openppm.core.dao.TeamMemberDAO.java

License:Open Source License

/**
 * Find team members filter by activity, employee and dates
 * //from ww w.jav a2  s  .  co m
 * @param employee
 * @param projectactivity
 * @param dateIn
 * @param dateOut
 * @param joins
 * @return
 */
public List<Teammember> findByActivityAndDates(Employee employee, Projectactivity projectactivity, Date dateIn,
        Date dateOut, List<String> joins) {

    Criteria crit = getSession().createCriteria(getPersistentClass());

    if (joins != null) {
        for (String join : joins) {
            crit.setFetchMode(join, FetchMode.JOIN);
        }
    }

    crit.add(Restrictions.eq(Teammember.EMPLOYEE, employee))
            .add(Restrictions.eq(Teammember.PROJECTACTIVITY, projectactivity));

    // Filter by dates (since && until)
    if (dateIn != null && dateOut != null) {

        crit.add(Restrictions.disjunction().add(Restrictions.between(Teammember.DATEIN, dateIn, dateOut))
                .add(Restrictions.between(Teammember.DATEOUT, dateIn, dateOut))
                .add(Restrictions.and(Restrictions.le(Teammember.DATEIN, dateIn),
                        Restrictions.ge(Teammember.DATEOUT, dateOut))));
    } else if (dateIn != null) {
        crit.add(Restrictions.and(Restrictions.le(Teammember.DATEIN, dateIn),
                Restrictions.ge(Teammember.DATEOUT, dateIn)));
    } else if (dateOut != null) {
        crit.add(Restrictions.and(Restrictions.le(Teammember.DATEIN, dateOut),
                Restrictions.ge(Teammember.DATEOUT, dateOut)));
    }

    return crit.list();
}

From source file:es.sm2.openppm.core.dao.TeamMemberDAO.java

License:Open Source License

/**
 * Time sheet not assigned to other team member
 * //from   w  ww . ja  v  a  2s  . c  om
 * @param member
 * @param timesheet
 * @return
 */
public boolean notAssignedToOtherMember(Teammember member, Timesheet timesheet) {

    Criteria crit = getSession().createCriteria(getPersistentClass()).setProjection(Projections.rowCount())
            .add(Restrictions.eq(Teammember.STATUS, Constants.RESOURCE_ASSIGNED))
            .add(Restrictions.eq(Teammember.EMPLOYEE, member.getEmployee()))
            .add(Restrictions.ne(Teammember.IDTEAMMEMBER, member.getIdTeamMember()))
            .add(Restrictions.eq(Teammember.PROJECTACTIVITY, member.getProjectactivity()));

    crit.add(Restrictions.disjunction()
            .add(Restrictions.between(Teammember.DATEIN, timesheet.getInitDate(), timesheet.getEndDate()))
            .add(Restrictions.between(Teammember.DATEOUT, timesheet.getInitDate(), timesheet.getEndDate()))
            .add(Restrictions.and(Restrictions.le(Teammember.DATEIN, timesheet.getInitDate()),
                    Restrictions.ge(Teammember.DATEOUT, timesheet.getEndDate()))));

    Integer count = (Integer) crit.uniqueResult();
    return !(count > 0);
}

From source file:es.sm2.openppm.core.dao.TeamMemberDAO.java

License:Open Source License

/**
 * Capacity planning resource //from   w  w w.  jav  a 2s  .  c om
 * 
 * @param idEmployee
 * @param since
 * @param until
 * @param statusList
 * @param joins
 * @param settings
 * @param user
  * @return
 */
public List<Teammember> capacityPlanningResource(Integer idEmployee, Date since, Date until,
        String[] statusList, List<String> joins, HashMap<String, String> settings, Employee user) {

    Criteria crit = getSession().createCriteria(getPersistentClass(), "t");

    // Filter by dates (since && until)
    if (since != null && until != null) {

        crit.add(Restrictions.disjunction().add(Restrictions.between(Teammember.DATEIN, since, until))
                .add(Restrictions.between(Teammember.DATEOUT, since, until))
                .add(Restrictions.and(Restrictions.le(Teammember.DATEIN, since),
                        Restrictions.ge(Teammember.DATEOUT, until))));
    } else if (since != null) {
        crit.add(Restrictions.and(Restrictions.le(Teammember.DATEIN, since),
                Restrictions.ge(Teammember.DATEOUT, since)));
    } else if (until != null) {
        crit.add(Restrictions.and(Restrictions.le(Teammember.DATEIN, until),
                Restrictions.ge(Teammember.DATEOUT, until)));
    }

    if (ValidateUtil.isNotNull(statusList)) {
        crit.add(Restrictions.in(Teammember.STATUS, statusList));
    }

    // Filter By Employee
    Criteria employeeCrit = crit.createCriteria(Teammember.EMPLOYEE);

    if (idEmployee != null) {
        employeeCrit.add(Restrictions.idEq(idEmployee));
    }

    // Joins
    //
    Criteria projActCrit = crit.createCriteria(Teammember.PROJECTACTIVITY);

    Criteria projCrit = projActCrit.createCriteria(Projectactivity.PROJECT);

    // Remove information if project is closed
    if (!SettingUtil.getBoolean(settings, SettingType.CLOSED_PROJECTS_CAPACITY_PLANNING)) {
        projCrit.add(Restrictions.and(Restrictions.ne(Project.STATUS, Constants.STATUS_CLOSED),
                Restrictions.ne(Project.STATUS, Constants.STATUS_ARCHIVED)));
    }

    addJoins(crit, joins);

    // PM Projects
    if (!SettingUtil.getBoolean(settings, GeneralSetting.PM_VIEW_OTHER_PROJECTS)
            && user.getResourceprofiles().getIdProfile() == Constants.ROLE_PM) {

        projCrit.add(Restrictions.eq(Project.EMPLOYEEBYPROJECTMANAGER, user));
    }

    // Orders
    //
    employeeCrit.createCriteria(Employee.CONTACT).addOrder(Order.asc(Contact.FULLNAME));

    projCrit.addOrder(Order.asc(Project.PROJECTNAME));

    projActCrit.addOrder(Order.asc(Projectactivity.ACTIVITYNAME));

    return crit.list();
}

From source file:es.sm2.openppm.core.dao.TimesheetDAO.java

License:Open Source License

public double getHoursResourceInDates(Project project, Employee member, Date since, Date until,
        Integer idResourcePool, Operation operation, Projectactivity activity) {

    Criteria crit = getSession().createCriteria(getPersistentClass());

    Criteria employeeCrit = null;//from   w w w.ja  v a 2 s . c  om

    if (member != null || idResourcePool != null) {
        employeeCrit = crit.createCriteria(Timesheet.EMPLOYEE);
    }

    if (idResourcePool != null) {
        employeeCrit.add(Restrictions.eq(Employee.RESOURCEPOOL, new Resourcepool(idResourcePool)));
    }

    if (member != null) {
        employeeCrit.add(Restrictions.idEq(member.getIdEmployee()));
    }

    if (since != null && until != null) {

        crit.add(Restrictions.disjunction().add(Restrictions.between(Timesheet.INITDATE, since, until))
                .add(Restrictions.between(Timesheet.ENDDATE, since, until))
                .add(Restrictions.and(Restrictions.le(Timesheet.INITDATE, since),
                        Restrictions.ge(Timesheet.ENDDATE, until))));
    }

    if (project != null) {

        crit.add(Restrictions.eq(Timesheet.STATUS, Constants.TIMESTATUS_APP3));

        Criteria activitiesCrit = crit.createCriteria(Timesheet.PROJECTACTIVITY)
                .add(Restrictions.eq(Projectactivity.PROJECT, project));

        // Select only timesheet whose activity is control account
        Criteria wbsnodeCrit = activitiesCrit.createCriteria(Projectactivity.WBSNODE)
                .add(Restrictions.eq(Wbsnode.ISCONTROLACCOUNT, true));
    } else if (operation != null) {

        crit.add(Restrictions.or(Restrictions.eq(Timesheet.STATUS, Constants.TIMESTATUS_APP2),
                Restrictions.eq(Timesheet.STATUS, Constants.TIMESTATUS_APP3)))
                .add(Restrictions.eq(Timesheet.OPERATION, operation));
    } else if (activity != null) {

        crit.add(Restrictions.eq(Timesheet.STATUS, Constants.TIMESTATUS_APP3))
                .add(Restrictions.eq(Timesheet.PROJECTACTIVITY, activity));
    }

    return calcHours(crit.list(), since, until);
}

From source file:es.tid.fiware.rss.dao.impl.DbeTransactionDaoImpl.java

License:Open Source License

@Override
public List<DbeTransaction> getTransactionBySvcPrdtUserDate(final Long nuServiceId, final Long nuProductId,
        final String enduserid, final Date rqDate) {
    DbeTransactionDaoImpl.LOGGER.debug("Entering getTransactionBySvcPrdtUserDate...");

    Criteria criteria = this.getSession().createCriteria(DbeTransaction.class);
    criteria.add(Restrictions.eq("bmService.nuServiceId", nuServiceId));
    if (nuProductId != null) {
        DbeTransactionDaoImpl.LOGGER.debug("product is NOT NULL");
        criteria.add(Restrictions.eq("bmProduct.nuProductId", nuProductId));

    }//  w  ww  . ja  va 2s. co m
    criteria.add(Restrictions.eq("txEndUserId", enduserid));

    DbeTransactionDaoImpl.LOGGER.debug("date of request:" + rqDate.toString());
    Calendar calendar = Calendar.getInstance();
    calendar.setTime(rqDate);
    int monthreq = calendar.get(Calendar.MONTH);
    DbeTransactionDaoImpl.LOGGER.debug("MONTH ini:" + monthreq);
    int yearreq = calendar.get(Calendar.YEAR);
    DbeTransactionDaoImpl.LOGGER.debug("YEAR ini:" + yearreq);
    int dayreq = calendar.get(Calendar.DATE);
    DbeTransactionDaoImpl.LOGGER.debug("DAY ini:" + dayreq);

    Calendar calini = Calendar.getInstance();
    calini.set(Calendar.YEAR, yearreq);
    calini.set(Calendar.MONTH, monthreq);
    calini.set(Calendar.DAY_OF_MONTH, dayreq);
    calini.set(Calendar.HOUR_OF_DAY, 0);
    calini.set(Calendar.MINUTE, 0);
    calini.set(Calendar.SECOND, 0);
    calini.set(Calendar.MILLISECOND, 0);
    Date dateini = calini.getTime();
    DbeTransactionDaoImpl.LOGGER.debug("string date ini:" + dateini.toString());
    DbeTransactionDaoImpl.LOGGER.debug("date ini:" + calini.get(Calendar.YEAR) + "-"
            + calini.get(Calendar.MONTH) + "-" + calini.get(Calendar.DATE) + "-" + calini.get(Calendar.HOUR)
            + "-" + calini.get(Calendar.MINUTE));

    Calendar calfin = Calendar.getInstance();
    calfin.set(Calendar.YEAR, yearreq);
    calfin.set(Calendar.MONTH, monthreq);
    calfin.set(Calendar.DAY_OF_MONTH, dayreq);
    calfin.set(Calendar.HOUR_OF_DAY, 23);
    calfin.set(Calendar.MINUTE, 59);
    calfin.set(Calendar.SECOND, 59);
    calfin.set(Calendar.MILLISECOND, 999);
    Date datefin = calfin.getTime();
    DbeTransactionDaoImpl.LOGGER.debug("string date fin:" + datefin.toString());
    DbeTransactionDaoImpl.LOGGER.debug("date fin:" + calfin.get(Calendar.YEAR) + "-"
            + calfin.get(Calendar.MONTH) + "-" + calfin.get(Calendar.DATE) + "-" + calfin.get(Calendar.HOUR)
            + "-" + calfin.get(Calendar.MINUTE));

    criteria.add(Restrictions.between("tsRequest", dateini, datefin));
    List<DbeTransaction> result = criteria.list();
    return result;

}