Example usage for org.hibernate.criterion DetachedCriteria setProjection

List of usage examples for org.hibernate.criterion DetachedCriteria setProjection

  1. HOME
  2. Java
  3. org.hibernate
  4. org.hibernate.criterion.*
  5. DetachedCriteria
  6. setProjection

Introduction

In this page you can find the example usage for org.hibernate.criterion DetachedCriteria setProjection.

Prototype

public DetachedCriteria setProjection(Projection projection)

Source Link

Document

Set the projection to use.

Usage

From source file:pula.sys.daos.impl.CourseClientDaoImpl.java

@Override
public MapBean unique(long id) {
    CourseClientCondition condition = new CourseClientCondition();
    condition.setId(id);//from w  w  w.j ava  2 s .co  m

    DetachedCriteria dc = makeDetachedCriteria(condition);

    ProjectionList proList = Projections.projectionList();// ?

    proList = HibernateTool.injectSingle(proList, SINGLE_MAPPING, "uu");
    proList = HibernateTool.injectSingle(proList, SINGLE_MAPPING_EXT, "uu");
    proList = HibernateTool.injectAlias(proList, ALIAS_MAPPING);
    dc.setProjection(proList);
    dc.setResultTransformer(Transformers.ALIAS_TO_ENTITY_MAP);

    Map<String, Object> map = super.uniqueResult(dc);

    return MapBean.map(map);
}

From source file:ro.cs.cm.model.dao.impl.DaoClientImpl.java

License:Open Source License

/**
 * Searches for clients using the criterion defined in searchClientBean
 * @author Coni//from   w ww  .  j a va2  s  .c  om
 * @param searchClientBean
 * @param isDeleteAction
 * @return
 */
public List<Client> getClientBeanFromSearch(SearchClientBean searchClientBean, boolean isDeleteAction) {
    logger.debug("getClientBeanFromSearch - START");

    DetachedCriteria dc = DetachedCriteria.forEntityName(IModelConstant.clientForListingEntity);
    DetachedCriteria dcCount = DetachedCriteria.forEntityName(IModelConstant.clientForListingEntity);

    if (searchClientBean.getOrganizationId() != -1) {
        dc.add(Restrictions.eq("organizationId", searchClientBean.getOrganizationId()));
        dcCount.add(Restrictions.eq("organizationId", searchClientBean.getOrganizationId()));
    }

    //if the c_name property is set it means it is a client of type firm and the p_firstName and
    //p_lastName properties of a person won't be set; there is a third case when the client search is first displayed, 
    //with no client type being selected 
    if (searchClientBean.getC_name() != null && !"".equals(searchClientBean.getC_name())
            && searchClientBean.getType() == IConstant.NOM_CLIENT_TYPE_FIRM) {
        dc.add(Restrictions.ilike("c_name", "%".concat(searchClientBean.getC_name().concat("%"))));
        dcCount.add(Restrictions.ilike("c_name", "%".concat(searchClientBean.getC_name().concat("%"))));
    } else if (searchClientBean.getC_name() != null && !"".equals(searchClientBean.getC_name())
            && searchClientBean.getType() == -1) { //no client type is selected, but the name field isn't empty
        //we consider the firstname and lastname that might have been entered are split by " "; if no space is entered, we consider it as the firstName
        String firstName = null;
        String lastName = null;
        if (searchClientBean.getC_name().lastIndexOf(" ") != -1) {
            firstName = searchClientBean.getC_name().substring(0,
                    searchClientBean.getC_name().lastIndexOf(" "));
            lastName = searchClientBean.getC_name()
                    .substring(searchClientBean.getC_name().lastIndexOf(" ") + 1);
        } else {
            firstName = searchClientBean.getC_name();
        }

        if (firstName != null && !"".equals(firstName) && lastName != null && !"".equals(lastName)) {
            dc.add(Restrictions.or(
                    Restrictions.ilike("c_name", "%".concat(searchClientBean.getC_name().concat("%"))),
                    Restrictions.and(Restrictions.ilike("p_firstName", "%".concat(firstName).concat("%")),
                            Restrictions.ilike("p_lastName", "%".concat(lastName).concat("%")))));
        } else if (firstName != null && !"".equals(firstName)) {
            dc.add(Restrictions.or(
                    Restrictions.ilike("c_name", "%".concat(searchClientBean.getC_name().concat("%"))),
                    Restrictions.ilike("p_firstName", "%".concat(firstName).concat("%"))));
        } else if (lastName != null && !"".equals(lastName)) {
            dc.add(Restrictions.or(
                    Restrictions.ilike("c_name", "%".concat(searchClientBean.getC_name().concat("%"))),
                    Restrictions.ilike("p_lastName", "%".concat(lastName).concat("%"))));
        }
    } else {
        if (searchClientBean.getP_firstName() != null && !"".equals(searchClientBean.getP_firstName())) {
            dc.add(Restrictions.ilike("p_firstName",
                    "%".concat(searchClientBean.getP_firstName().concat("%"))));
            dcCount.add(Restrictions.ilike("p_firstName",
                    "%".concat(searchClientBean.getP_firstName().concat("%"))));
        }
        if (searchClientBean.getP_lastName() != null && !"".equals(searchClientBean.getP_lastName())) {
            dc.add(Restrictions.ilike("p_lastName", "%".concat(searchClientBean.getP_lastName().concat("%"))));
            dcCount.add(
                    Restrictions.ilike("p_lastName", "%".concat(searchClientBean.getP_lastName().concat("%"))));
        }
    }

    if (searchClientBean.getEmail() != null && !"".equals(searchClientBean.getEmail())) {
        dc.add(Restrictions.ilike("email", "%".concat(searchClientBean.getEmail().concat("%"))));
        dcCount.add(Restrictions.ilike("email", "%".concat(searchClientBean.getEmail().concat("%"))));
    }

    if (searchClientBean.getAddress() != null && !"".equals(searchClientBean.getAddress())) {
        dc.add(Restrictions.ilike("address", "%".concat(searchClientBean.getAddress().concat("%"))));
        dcCount.add(Restrictions.ilike("address", "%".concat(searchClientBean.getAddress().concat("%"))));
    }

    if (searchClientBean.getType() != -1) {
        dc.add(Restrictions.eq("type", searchClientBean.getType()));
        dcCount.add(Restrictions.eq("type", searchClientBean.getType()));
    }

    if (searchClientBean.getStatus() != -1) {
        dc.add(Restrictions.eq("status", searchClientBean.getStatus()));
        dcCount.add(Restrictions.eq("status", searchClientBean.getStatus()));
    }

    // check if I have to order the results
    if (searchClientBean.getSortParam() != null && !"".equals(searchClientBean.getSortParam())
            && !IConstant.NOM_CLIENT_SORT_PARAM_NAME.equals(searchClientBean.getSortParam())) {
        // if I have to, check if I have to order them ascending or descending
        if (searchClientBean.getSortDirection() == -1) {
            // ascending
            dc.addOrder(Order.asc(searchClientBean.getSortParam()));
        } else {
            // descending
            dc.addOrder(Order.desc(searchClientBean.getSortParam()));
        }
    }

    // if the request didn't come from the pagination area, 
    // it means that I have to set the number of results and pages
    if (isDeleteAction || searchClientBean.getNbrOfResults() == -1) {
        boolean isSearch = false;
        if (searchClientBean.getNbrOfResults() == -1) {
            isSearch = true;
        }
        // set the count(*) restriction         
        dcCount.setProjection(Projections.countDistinct("clientId"));

        //findByCriteria must be called with firstResult and maxResults parameters; the default findByCriteria(DetachedCriteria criteria) implementation
        //sets firstResult and maxResults to -1, which kills the countDistinct Projection         
        int nbrOfResults = ((Integer) getHibernateTemplate().findByCriteria(dcCount, 0, 0).get(0)).intValue();
        logger.debug("search results: ".concat(String.valueOf(nbrOfResults)));
        searchClientBean.setNbrOfResults(nbrOfResults);

        // get the number of pages
        if (nbrOfResults % searchClientBean.getResultsPerPage() == 0) {
            searchClientBean.setNbrOfPages(nbrOfResults / searchClientBean.getResultsPerPage());
        } else {
            searchClientBean.setNbrOfPages(nbrOfResults / searchClientBean.getResultsPerPage() + 1);
        }
        // after a client is deleted, the same page has to be displayed;
        //only when all the client from last page are deleted, the previous page will be shown 
        if (isDeleteAction && (searchClientBean.getCurrentPage() > searchClientBean.getNbrOfPages())) {
            searchClientBean.setCurrentPage(searchClientBean.getNbrOfPages());
        } else if (isSearch) {
            searchClientBean.setCurrentPage(1);
        }

    }

    List<Client> res = (List<Client>) getHibernateTemplate().findByCriteria(dc,
            (searchClientBean.getCurrentPage() - 1) * searchClientBean.getResultsPerPage(),
            searchClientBean.getResultsPerPage());
    logger.debug("getClientBeanFromSearch - END results size : ".concat(String.valueOf(res.size())));
    return res;
}

From source file:ro.cs.cm.model.dao.impl.DaoProjectImpl.java

License:Open Source License

/**
 * Searches for Projects after criterion from searchProjectBean.
 * //from  ww w.ja v a  2  s .  c  om
 * @author Adelina
 * 
 * @param searchProjectBean
 * @param statusIds
 * @param isDeleteAction
 * @return
 */
public List<Project> getFromSearch(SearchProjectBean searchProjectBean, Set<Byte> statusIds,
        Set<Integer> clientIds, boolean isDeleteAction, MessageSource messageSource) {
    logger.debug("getFromSearch - START - ");

    UserAuth userAuth = (UserAuth) SecurityContextHolder.getContext().getAuthentication().getPrincipal();

    // set search criterion
    DetachedCriteria dc = DetachedCriteria.forEntityName(IModelConstant.projectAllEntity);
    DetachedCriteria dcCount = DetachedCriteria.forEntityName(IModelConstant.projectAllEntity);

    if (searchProjectBean.getOrganizationId() != -1) {
        dc.add(Restrictions.eq("organizationId", searchProjectBean.getOrganizationId()));
        dcCount.add(Restrictions.eq("organizationId", searchProjectBean.getOrganizationId()));
    }

    if (!userAuth.hasAuthority(PermissionConstant.getInstance().getCM_ProjectAdvancedSearch())) {
        // search only for projects that the user belongs to (such as manager or member)         

        List<TeamMember> members = new ArrayList<TeamMember>();

        List<ProjectTeam> projectTeams = new ArrayList<ProjectTeam>();

        List<Integer> projectIds = new ArrayList<Integer>();

        DetachedCriteria dc1 = DetachedCriteria.forEntityName(IModelConstant.teamMemberEntity);
        dc1.add(Restrictions.eq("personId", userAuth.getPersonId()));
        dc1.add(Restrictions.ne("status", IConstant.NOM_TEAM_MEMBER_STATUS_DELETED));
        members = getHibernateTemplate().findByCriteria(dc1);
        logger.debug("members = " + members);

        if (members != null && members.size() > 0) {
            for (TeamMember user : members) {
                logger.debug("user = " + user);
                DetachedCriteria dcProjTeam = DetachedCriteria.forEntityName(IModelConstant.projectTeamEntity);
                dcProjTeam.add(Restrictions.eq("projectTeamId", user.getProjectTeamId()));
                dcProjTeam.add(Restrictions.ne("status", IConstant.NOM_PROJECT_TEAM_STATUS_DELETED));
                projectTeams = getHibernateTemplate().findByCriteria(dcProjTeam);
                logger.debug("project teams = " + projectTeams);
                if (projectTeams != null && projectTeams.size() > 0) {
                    for (ProjectTeam projectTeam : projectTeams) {
                        logger.debug("project team = " + projectTeam);
                        projectIds.add(projectTeam.getProjectId());
                    }
                }
            }
        }

        if (projectTeams == null || projectTeams.size() == 0) {
            projectIds.add(new Integer(-1));
        }

        logger.debug("projectIds = " + projectIds);
        if (projectIds != null && projectIds.size() > 0) {
            dc.add(Expression.or(Expression.eq("managerId", userAuth.getPersonId()),
                    Restrictions.in("projectId", projectIds)));
            dcCount.add(Expression.or(Expression.eq("managerId", userAuth.getPersonId()),
                    Restrictions.in("projectId", projectIds)));
        }
    }

    logger.debug("managerId = " + searchProjectBean.getManagerId());

    // manager      
    if (searchProjectBean.getManagerId() != null && searchProjectBean.getManagerId() != -1) {
        dc.add(Restrictions.eq("managerId", searchProjectBean.getManagerId()));
        dcCount.add(Restrictions.eq("managerId", searchProjectBean.getManagerId()));
        logger.debug("ManagerId Id: " + searchProjectBean.getManagerId());
    }

    // name
    if (Tools.getInstance().stringNotEmpty(searchProjectBean.getName())) {
        dc.add(Restrictions.ilike("name", "%".concat(searchProjectBean.getName().concat("%"))));
        dcCount.add(Restrictions.ilike("name", "%".concat(searchProjectBean.getName().concat("%"))));
        logger.debug("name = " + searchProjectBean.getName());
    }

    logger.debug("clientId = " + searchProjectBean.getClientId());
    logger.debug("clientsIds = " + clientIds);

    // client
    if (searchProjectBean.getClientId() != null && searchProjectBean.getClientId() != 0) {
        dc.add(Restrictions.like("clientId", searchProjectBean.getClientId()));
        dcCount.add(Restrictions.like("clientId", searchProjectBean.getClientId()));
    } else {
        dc.add(Restrictions.in("clientId", clientIds));
        dcCount.add(Restrictions.in("clientId", clientIds));
    }

    //If the user didn't select at least one status then we'll make a search on all of these criterions
    // Status
    if (searchProjectBean.getStatus() != -1) {
        dc.add(Restrictions.eq("status", searchProjectBean.getStatus()));
        dcCount.add(Restrictions.eq("status", searchProjectBean.getStatus()));
    } else {
        dc.add(Restrictions.in("status", statusIds));
        dcCount.add(Restrictions.in("status", statusIds));
    }

    List<Project> res = null;

    //the order can be done while retrieving the data from the database only if the sort parameter is the project name or status;
    //this cannot be done if the results must be ordered by the client name
    if (searchProjectBean.getSortParam() != null && !"".equals(searchProjectBean.getSortParam())
            && !"clientName".equals(searchProjectBean.getSortParam())) {
        // check if I have to order the results
        // if I have to, check if I have to order them ascending or descending
        if (searchProjectBean.getSortDirection() == -1) {
            // ascending
            dc.addOrder(Order.asc(searchProjectBean.getSortParam()));
        } else {
            // descending
            dc.addOrder(Order.desc(searchProjectBean.getSortParam()));
        }

        // if the request didn't come from the pagination area, 
        // it means that I have to set the number of results and pages
        if (isDeleteAction || searchProjectBean.getNbrOfResults() == -1) {
            boolean isSearch = false;
            if (searchProjectBean.getNbrOfResults() == -1) {
                isSearch = true;
            }
            // set the count(*) restriction         
            dcCount.setProjection(Projections.countDistinct("projectId"));

            //findByCriteria must be called with firstResult and maxResults parameters; the default findByCriteria(DetachedCriteria criteria) implementation
            //sets firstResult and maxResults to -1, which kills the countDistinct Projection         
            int nbrOfResults = ((Integer) getHibernateTemplate().findByCriteria(dcCount, 0, 0).get(0))
                    .intValue();
            logger.debug("search results: ".concat(String.valueOf(nbrOfResults)));
            searchProjectBean.setNbrOfResults(nbrOfResults);

            // get the number of pages
            if (nbrOfResults % searchProjectBean.getResultsPerPage() == 0) {
                searchProjectBean.setNbrOfPages(nbrOfResults / searchProjectBean.getResultsPerPage());
            } else {
                searchProjectBean.setNbrOfPages(nbrOfResults / searchProjectBean.getResultsPerPage() + 1);
            }
            // after a project is deleted, the same page has to be displayed;
            //only when all the client from last page are deleted, the previous page will be shown 
            if (isDeleteAction && (searchProjectBean.getCurrentPage() > searchProjectBean.getNbrOfPages())) {
                searchProjectBean.setCurrentPage(searchProjectBean.getNbrOfPages());
            } else if (isSearch) {
                searchProjectBean.setCurrentPage(1);
            }
        }

        res = (List<Project>) getHibernateTemplate().findByCriteria(dc,
                (searchProjectBean.getCurrentPage() - 1) * searchProjectBean.getResultsPerPage(),
                searchProjectBean.getResultsPerPage());
    } else {
        res = (List<Project>) getHibernateTemplate().findByCriteria(dc);
        // if the request didn't come from the pagination area, 
        // it means that I have to set the number of results and pages
        if (isDeleteAction || searchProjectBean.getNbrOfResults() == -1) {
            boolean isSearch = false;
            if (searchProjectBean.getNbrOfResults() == -1) {
                isSearch = true;
            }
            int nbrOfResults = res.size();
            logger.debug("search results: ".concat(String.valueOf(nbrOfResults)));
            searchProjectBean.setNbrOfResults(nbrOfResults);

            // get the number of pages
            if (nbrOfResults % searchProjectBean.getResultsPerPage() == 0) {
                searchProjectBean.setNbrOfPages(nbrOfResults / searchProjectBean.getResultsPerPage());
            } else {
                searchProjectBean.setNbrOfPages(nbrOfResults / searchProjectBean.getResultsPerPage() + 1);
            }
            // after an exchange is deleted, the same page has to be displayed;
            //only when all the exchanges from last page are deleted, the previous page will be shown 
            if (isDeleteAction && (searchProjectBean.getCurrentPage() > searchProjectBean.getNbrOfPages())) {
                searchProjectBean.setCurrentPage(searchProjectBean.getNbrOfPages());
            } else if (isSearch) {
                searchProjectBean.setCurrentPage(1);
            }
        }
    }

    List<Project> newRes = new ArrayList<Project>();

    if (res != null && res.size() > 0) {
        // for every project
        for (Project project : res) {
            Project projectNew = getWithAll(project.getProjectId());
            if (projectNew.getClientId() != null && projectNew.getClientId() > 0) {
                Client client = projectNew.getClient();
                if (client != null) {
                    if (client.getType() == IConstant.NOM_CLIENT_TYPE_FIRM) {
                        projectNew.setClientName(client.getC_name());
                    } else {
                        projectNew.setClientName(
                                client.getP_firstName().concat(" ").concat(client.getP_lastName()));
                    }
                }
            } else {
                projectNew.setClientName(messageSource.getMessage(CLIENT_FROM_ORG, null, null));
            }

            newRes.add(projectNew);
        }
    }

    List<Project> projects = new ArrayList<Project>();
    //sorting the exchanges list
    if (searchProjectBean.getSortParam() != null && searchProjectBean.getSortParam().equals("clientName")) {
        Collections.sort(newRes, ProjectComparator.getInstance().projectClientNameComparator());

        //ascending or descending
        if (searchProjectBean.getSortDirection() == IConstant.DESCENDING) {
            Collections.reverse(newRes);
        }

        long start = (searchProjectBean.getCurrentPage() - 1) * searchProjectBean.getResultsPerPage();
        long end = searchProjectBean.getCurrentPage() * searchProjectBean.getResultsPerPage();

        // go over the entries      
        if (newRes.size() > 0) {
            for (int i = (int) start; i < end; i++) {
                if (i >= newRes.size()) {
                    continue;
                }
                projects.add(newRes.get(i));
            }
        }
    } else {
        projects = newRes;
    }

    logger.debug("getFromSearch - END - results size : ".concat(String.valueOf(projects.size())));

    return projects;
}

From source file:ro.cs.cm.model.dao.impl.DaoTeamMemberImpl.java

License:Open Source License

/**
 * Retrieves from search a list of team members with basic info and pagination; search method
 * for TS person search/*from www  .  j av  a2  s  .  com*/
 * 
 * @author Coni
 * @param searchTeamMemberBean
 * @return
 * @throws WSClientException 
 * @throws IOException 
 * @throws XmlMappingException 
 * @throws BusinessException 
 */
public List<TeamMember> getFromSearchSimpleWithPagination(SearchTeamMemberBean searchTeamMemberBean)
        throws XmlMappingException, IOException, WSClientException, BusinessException {
    logger.debug("getFromSearchSimpleWithPagination - START");

    DetachedCriteria dc = DetachedCriteria
            .forEntityName(IModelConstant.teamMemberWithProjectTeamAndProjectEntity);
    DetachedCriteria dcCount = DetachedCriteria
            .forEntityName(IModelConstant.teamMemberWithProjectTeamAndProjectEntity);

    //retrieve all the team members for persons from the organization(which have personId !=  0) or 
    //not(which have firstName and lastName) that correspond to the search criteria
    if (searchTeamMemberBean.getFirstName() != null && !"".equals(searchTeamMemberBean.getFirstName())
            && searchTeamMemberBean.getLastName() != null && !"".equals(searchTeamMemberBean.getLastName())) {
        dc.add(Restrictions.and(
                Restrictions.ilike("firstName", "%".concat(searchTeamMemberBean.getFirstName()).concat("%")),
                Restrictions.ilike("lastName", "%".concat(searchTeamMemberBean.getLastName()).concat("%"))));
        dcCount.add(Restrictions.and(
                Restrictions.ilike("firstName", "%".concat(searchTeamMemberBean.getFirstName()).concat("%")),
                Restrictions.ilike("lastName", "%".concat(searchTeamMemberBean.getLastName()).concat("%"))));
    } else if (searchTeamMemberBean.getFirstName() != null && !"".equals(searchTeamMemberBean.getFirstName())) {
        dc.add(Restrictions.ilike("firstName", "%".concat(searchTeamMemberBean.getFirstName()).concat("%")));
        dcCount.add(
                Restrictions.ilike("firstName", "%".concat(searchTeamMemberBean.getFirstName()).concat("%")));
    } else if (searchTeamMemberBean.getLastName() != null && !"".equals(searchTeamMemberBean.getLastName())) {
        dc.add(Restrictions.ilike("lastName", "%".concat(searchTeamMemberBean.getLastName()).concat("%")));
        dcCount.add(Restrictions.ilike("lastName", "%".concat(searchTeamMemberBean.getLastName()).concat("%")));
    }

    if (!searchTeamMemberBean.isWithDeleted()) {
        dc.add(Restrictions.eq("status", IConstant.NOM_TEAM_MEMBER_STATUS_ACTIVATED));
        dcCount.add(Restrictions.eq("status", IConstant.NOM_TEAM_MEMBER_STATUS_ACTIVATED));
    }

    DetachedCriteria dcOnProject = dc.createCriteria("projectTeam").createCriteria("project");
    DetachedCriteria dcCountOnProject = dcCount.createCriteria("projectTeam").createCriteria("project");
    if (searchTeamMemberBean.getProjectId() != null && !searchTeamMemberBean.getProjectId()
            .equals(Integer.valueOf(IConstant.NOM_TS_PERSON_SEARCH_IN_ORGANIZATION))) {
        if (searchTeamMemberBean.getProjectId()
                .equals(Integer.valueOf(IConstant.NOM_TS_PERSON_SEARCH_ALL_PROJECTS))) {
            //if the used doesn't have the permission to search in all the projects for team members, 
            //the user must see all the persons from the projects where he is PM and only his person
            //for the projects where he isn't PM
            List<Project> userProjects = null;
            if (!searchTeamMemberBean.isHasPermissionToSeeAllProjects()) {
                if (!searchTeamMemberBean.isOnlyManager()) {
                    userProjects = BLProject.getInstance().getProjectsByPerson(
                            searchTeamMemberBean.getPersonId(),
                            searchTeamMemberBean.isIncludeFinishedAndAbandonedProjects());
                } else {
                    userProjects = BLProject.getInstance().getProjectsByManager(
                            searchTeamMemberBean.getPersonId(),
                            searchTeamMemberBean.isIncludeFinishedAndAbandonedProjects());
                }
            } else {
                userProjects = BLProject.getInstance().getAllProjects(searchTeamMemberBean.getOrganizationId(),
                        searchTeamMemberBean.isIncludeFinishedAndAbandonedProjects());
            }
            if (userProjects != null && !userProjects.isEmpty()) {
                List<Integer> projectIds = new ArrayList<Integer>();
                for (Project prj : userProjects) {
                    projectIds.add(prj.getProjectId());
                }
                dcOnProject.add(Restrictions.in("projectId", projectIds));
                dcCountOnProject.add(Restrictions.in("projectId", projectIds));
            } else {
                return new ArrayList<TeamMember>();
            }
        } else {
            //if a project is selected, the team members project team must correspond to that project
            dcOnProject.add(Restrictions.eq("projectId", searchTeamMemberBean.getProjectId()));
            dcCountOnProject.add(Restrictions.eq("projectId", searchTeamMemberBean.getProjectId()));
        }
    }

    if (searchTeamMemberBean.getOrganizationId() != null) {
        dcOnProject.add(Restrictions.eq("organizationId", searchTeamMemberBean.getOrganizationId()));
        dcCountOnProject.add(Restrictions.eq("organizationId", searchTeamMemberBean.getOrganizationId()));
    }

    // check if I have to order the results
    if (searchTeamMemberBean.getSortParam() != null
            && StringUtils.hasLength(searchTeamMemberBean.getSortParam())) {
        if (searchTeamMemberBean.getSortParam().equals("projectName")) {
            if (searchTeamMemberBean.getSortDirection() == IConstant.ASCENDING) {
                dcOnProject.addOrder(Order.asc("name"));
            } else {
                dcOnProject.addOrder(Order.desc("name"));
            }
        } else {
            // if I have to, check if I have to order them ascending or descending
            if (searchTeamMemberBean.getSortDirection() == IConstant.ASCENDING) {
                // ascending
                dc.addOrder(Order.asc(searchTeamMemberBean.getSortParam()));
            } else {
                // descending
                dc.addOrder(Order.desc(searchTeamMemberBean.getSortParam()));
            }
        }
    }

    // if the request didn't come from the pagination area, 
    // it means that I have to set the number of result and pages
    if (searchTeamMemberBean.getNbrOfResults() == -1) {
        // set the countDistinct restriction
        dcCount.setProjection(Projections.countDistinct("memberId"));

        int nbrOfResults = ((Integer) getHibernateTemplate().findByCriteria(dcCount, 0, 0).get(0)).intValue();
        searchTeamMemberBean.setNbrOfResults(nbrOfResults);
        logger.debug("NbrOfResults " + searchTeamMemberBean.getNbrOfResults());
        logger.debug("----> searchPersonBean.getResults " + searchTeamMemberBean.getResultsPerPage());
        // get the number of pages
        if (nbrOfResults % searchTeamMemberBean.getResultsPerPage() == 0) {
            searchTeamMemberBean.setNbrOfPages(nbrOfResults / searchTeamMemberBean.getResultsPerPage());
        } else {
            searchTeamMemberBean.setNbrOfPages(nbrOfResults / searchTeamMemberBean.getResultsPerPage() + 1);
        }
        searchTeamMemberBean.setCurrentPage(1);
    }

    List<TeamMember> res = getHibernateTemplate().findByCriteria(dc,
            (searchTeamMemberBean.getCurrentPage() - 1) * searchTeamMemberBean.getResultsPerPage(),
            searchTeamMemberBean.getResultsPerPage());

    logger.debug("getFromSearchSimpleWithPagination - END");
    return res;
}

From source file:ro.cs.logaudit.dao.impl.DaoAuditCmImpl.java

License:Open Source License

/**
 * Searches for audit after criterion from searchBean
 * /*from w ww. ja v  a  2 s  .c o m*/
 * @author Coni
 * 
 * @return A list of audit beans 
 * @throws ParseException 
 */
public List<AuditCmBean> getAuditBeanFromSearch(SearchAuditCmBean searchAuditCmBean, boolean isDeleteAction,
        Locale locale) throws ParseException {

    logger.debug("getAuditBeanFromSearch - START");

    // set search criterion
    DetachedCriteria dc = DetachedCriteria.forEntityName(IModelConstant.auditcmEntity);
    DetachedCriteria dcCount = DetachedCriteria.forEntityName(IModelConstant.auditcmEntity);

    if (searchAuditCmBean.getOrganisationId() != -1) {
        dc.add(Restrictions.eq("organisationId", searchAuditCmBean.getOrganisationId()));
        dcCount.add(Restrictions.eq("organisationId", searchAuditCmBean.getOrganisationId()));
    }

    if (searchAuditCmBean.getEvent() != null && !"-1".equals(searchAuditCmBean.getEvent())) {
        dc.add(Restrictions.ilike("event", "%".concat(searchAuditCmBean.getEvent()).concat("%")));
        dcCount.add(Restrictions.ilike("event", "%".concat(searchAuditCmBean.getEvent()).concat("%")));
    }
    if (searchAuditCmBean.getPersonId() != null && !"".equals(searchAuditCmBean.getPersonId())) {
        dc.add(Restrictions.eq("personId", searchAuditCmBean.getPersonId()));
        dcCount.add(Restrictions.eq("personId", searchAuditCmBean.getPersonId()));
    }
    if (searchAuditCmBean.getMessage() != null && !"".equals(searchAuditCmBean.getMessage())) {
        dc.add(Restrictions.ilike("message".concat(locale.toString().toUpperCase()),
                "%".concat(searchAuditCmBean.getMessage()).concat("%")));
        dcCount.add(Restrictions.ilike("message".concat(locale.toString().toUpperCase()),
                "%".concat(searchAuditCmBean.getMessage()).concat("%")));
    }

    if (searchAuditCmBean.getStartDate() != null) {
        dc.add(Expression.ge("date", searchAuditCmBean.getStartDate()));
        dcCount.add(Expression.ge("date", searchAuditCmBean.getStartDate()));
    }

    if (searchAuditCmBean.getEndDate() != null) {
        dc.add(Expression.le("date", searchAuditCmBean.getEndDate()));
        dcCount.add(Expression.le("date", searchAuditCmBean.getEndDate()));
    }

    // check if I have to order the results
    if (searchAuditCmBean.getSortParam() != null && !"".equals(searchAuditCmBean.getSortParam())) {
        // if I have to, check if I have to order them ascending or descending
        if (searchAuditCmBean.getSortDirection() == -1) {
            // ascending
            dc.addOrder(Order.asc(searchAuditCmBean.getSortParam()));
        } else {
            // descending
            dc.addOrder(Order.desc(searchAuditCmBean.getSortParam()));
        }
    }

    // if the request didn't come from the pagination area, 
    // it means that I have to set the number of results and pages
    if (isDeleteAction || searchAuditCmBean.getNbrOfResults() == -1) {
        boolean isSearch = false;
        if (searchAuditCmBean.getNbrOfResults() == -1) {
            isSearch = true;
        }
        // set the count(*) restriction         
        dcCount.setProjection(Projections.countDistinct("auditId"));

        //findByCriteria must be called with firstResult and maxResults parameters; the default findByCriteria(DetachedCriteria criteria) implementation
        //sets firstResult and maxResults to -1, which kills the countDistinct Projection         
        int nbrOfResults = ((Integer) getHibernateTemplate().findByCriteria(dcCount, 0, 0).get(0)).intValue();
        logger.debug("search results: ".concat(String.valueOf(nbrOfResults)));
        searchAuditCmBean.setNbrOfResults(nbrOfResults);

        // get the number of pages
        if (nbrOfResults % searchAuditCmBean.getResultsPerPage() == 0) {
            searchAuditCmBean.setNbrOfPages(nbrOfResults / searchAuditCmBean.getResultsPerPage());
        } else {
            searchAuditCmBean.setNbrOfPages(nbrOfResults / searchAuditCmBean.getResultsPerPage() + 1);
        }
        // after an audit is deleted, the same page has to be displayed;
        //only when all the audit events from last page are deleted, the previous page will be shown 
        if (isDeleteAction && (searchAuditCmBean.getCurrentPage() > searchAuditCmBean.getNbrOfPages())) {
            searchAuditCmBean.setCurrentPage(searchAuditCmBean.getNbrOfPages());
        } else if (isSearch) {
            searchAuditCmBean.setCurrentPage(1);
        }

    }

    List<AuditCmBean> res = (List<AuditCmBean>) getHibernateTemplate().findByCriteria(dc,
            (searchAuditCmBean.getCurrentPage() - 1) * searchAuditCmBean.getResultsPerPage(),
            searchAuditCmBean.getResultsPerPage());
    logger.debug("getAuditBeanFromSearch - END results size : ".concat(String.valueOf(res.size())));
    return res;
}

From source file:ro.cs.logaudit.dao.impl.DaoAuditDmImpl.java

License:Open Source License

/**
 * Searches for audit after criterion from searchBean
 * /*from w w  w .  ja  v a2  s .  c o  m*/
 * @author coni
 * 
 * @return A list of audit beans 
 * @throws ParseException 
 */
public List<AuditDmBean> getAuditBeanFromSearch(SearchAuditDmBean searchAuditDmBean, boolean isDeleteAction,
        Locale locale) throws ParseException {

    logger.debug("getAuditBeanFromSearch - START");

    // set search criterion
    DetachedCriteria dc = DetachedCriteria.forEntityName(IModelConstant.auditdmEntity);
    DetachedCriteria dcCount = DetachedCriteria.forEntityName(IModelConstant.auditdmEntity);

    if (searchAuditDmBean.getOrganisationId() != -1) {
        dc.add(Restrictions.eq("organisationId", searchAuditDmBean.getOrganisationId()));
        dcCount.add(Restrictions.eq("organisationId", searchAuditDmBean.getOrganisationId()));
    }

    if (searchAuditDmBean.getEvent() != null && !"-1".equals(searchAuditDmBean.getEvent())) {
        dc.add(Restrictions.ilike("event", "%".concat(searchAuditDmBean.getEvent()).concat("%")));
        dcCount.add(Restrictions.ilike("event", "%".concat(searchAuditDmBean.getEvent()).concat("%")));
    }
    if (searchAuditDmBean.getPersonId() != null && !"".equals(searchAuditDmBean.getPersonId())) {
        dc.add(Restrictions.eq("personId", searchAuditDmBean.getPersonId()));
        dcCount.add(Restrictions.eq("personId", searchAuditDmBean.getPersonId()));
    }
    if (searchAuditDmBean.getMessage() != null && !"".equals(searchAuditDmBean.getMessage())) {
        dc.add(Restrictions.ilike("message".concat(locale.toString().toUpperCase()),
                "%".concat(searchAuditDmBean.getMessage()).concat("%")));
        dcCount.add(Restrictions.ilike("message".concat(locale.toString().toUpperCase()),
                "%".concat(searchAuditDmBean.getMessage()).concat("%")));
    }

    if (searchAuditDmBean.getStartDate() != null) {
        dc.add(Expression.ge("date", searchAuditDmBean.getStartDate()));
        dcCount.add(Expression.ge("date", searchAuditDmBean.getStartDate()));
    }

    if (searchAuditDmBean.getEndDate() != null) {
        dc.add(Expression.le("date", searchAuditDmBean.getEndDate()));
        dcCount.add(Expression.le("date", searchAuditDmBean.getEndDate()));
    }

    // check if I have to order the results
    if (searchAuditDmBean.getSortParam() != null && !"".equals(searchAuditDmBean.getSortParam())) {
        // if I have to, check if I have to order them ascending or descending
        if (searchAuditDmBean.getSortDirection() == -1) {
            // ascending
            dc.addOrder(Order.asc(searchAuditDmBean.getSortParam()));
        } else {
            // descending
            dc.addOrder(Order.desc(searchAuditDmBean.getSortParam()));
        }
    }

    // if the request didn't come from the pagination area, 
    // it means that I have to set the number of results and pages
    if (isDeleteAction || searchAuditDmBean.getNbrOfResults() == -1) {
        boolean isSearch = false;
        if (searchAuditDmBean.getNbrOfResults() == -1) {
            isSearch = true;
        }
        // set the count(*) restriction         
        dcCount.setProjection(Projections.countDistinct("auditId"));

        //findByCriteria must be called with firstResult and maxResults parameters; the default findByCriteria(DetachedCriteria criteria) implementation
        //sets firstResult and maxResults to -1, which kills the countDistinct Projection         
        int nbrOfResults = ((Integer) getHibernateTemplate().findByCriteria(dcCount, 0, 0).get(0)).intValue();
        logger.debug("search results: ".concat(String.valueOf(nbrOfResults)));
        searchAuditDmBean.setNbrOfResults(nbrOfResults);

        // get the number of pages
        if (nbrOfResults % searchAuditDmBean.getResultsPerPage() == 0) {
            searchAuditDmBean.setNbrOfPages(nbrOfResults / searchAuditDmBean.getResultsPerPage());
        } else {
            searchAuditDmBean.setNbrOfPages(nbrOfResults / searchAuditDmBean.getResultsPerPage() + 1);
        }
        // after an audit is deleted, the same page has to be displayed;
        //only when all the roles from last page are deleted, the previous page will be shown 
        if (isDeleteAction && (searchAuditDmBean.getCurrentPage() > searchAuditDmBean.getNbrOfPages())) {
            searchAuditDmBean.setCurrentPage(searchAuditDmBean.getNbrOfPages());
        } else if (isSearch) {
            searchAuditDmBean.setCurrentPage(1);
        }

    }

    List<AuditDmBean> res = (List<AuditDmBean>) getHibernateTemplate().findByCriteria(dc,
            (searchAuditDmBean.getCurrentPage() - 1) * searchAuditDmBean.getResultsPerPage(),
            searchAuditDmBean.getResultsPerPage());
    logger.debug("getAuditBeanFromSearch - END results size : ".concat(String.valueOf(res.size())));
    return res;
}

From source file:ro.cs.logaudit.dao.impl.DaoAuditOmImpl.java

License:Open Source License

/**
 * Searches for audit after criterion from searchBean
 * //from w  w  w. j ava  2 s  . c o  m
 * @author Adelina
 * @author Coni
 * 
 * @return A list of audit beans 
 * @throws ParseException 
 */
public List<AuditOmBean> getAuditBeanFromSearch(SearchAuditOmBean searchAuditOmBean, boolean isDeleteAction,
        Locale locale) throws ParseException {

    logger.debug("getAuditBeanFromSearch - START");

    // set search criterion
    DetachedCriteria dc = DetachedCriteria.forEntityName(IModelConstant.auditomEntity);
    DetachedCriteria dcCount = DetachedCriteria.forEntityName(IModelConstant.auditomEntity);

    if (searchAuditOmBean.getOrganisationId() != -1) {
        dc.add(Restrictions.eq("organisationId", searchAuditOmBean.getOrganisationId()));
        dcCount.add(Restrictions.eq("organisationId", searchAuditOmBean.getOrganisationId()));
    }

    if (searchAuditOmBean.getEvent() != null && !"-1".equals(searchAuditOmBean.getEvent())) {
        dc.add(Restrictions.ilike("event", "%".concat(searchAuditOmBean.getEvent()).concat("%")));
        dcCount.add(Restrictions.ilike("event", "%".concat(searchAuditOmBean.getEvent()).concat("%")));
    }
    if (searchAuditOmBean.getPersonId() != null && !"".equals(searchAuditOmBean.getPersonId())) {
        dc.add(Restrictions.eq("personId", searchAuditOmBean.getPersonId()));
        dcCount.add(Restrictions.eq("personId", searchAuditOmBean.getPersonId()));
    }
    if (searchAuditOmBean.getMessage() != null && !"".equals(searchAuditOmBean.getMessage())) {
        dc.add(Restrictions.ilike("message".concat(locale.toString().toUpperCase()),
                "%".concat(searchAuditOmBean.getMessage()).concat("%")));
        dcCount.add(Restrictions.ilike("message".concat(locale.toString().toUpperCase()),
                "%".concat(searchAuditOmBean.getMessage()).concat("%")));
    }

    if (searchAuditOmBean.getStartDate() != null) {
        dc.add(Expression.ge("date", searchAuditOmBean.getStartDate()));
        dcCount.add(Expression.ge("date", searchAuditOmBean.getStartDate()));
    }

    if (searchAuditOmBean.getEndDate() != null) {
        dc.add(Expression.le("date", searchAuditOmBean.getEndDate()));
        dcCount.add(Expression.le("date", searchAuditOmBean.getEndDate()));
    }

    // check if I have to order the results
    if (searchAuditOmBean.getSortParam() != null && !"".equals(searchAuditOmBean.getSortParam())) {
        // if I have to, check if I have to order them ascending or descending
        if (searchAuditOmBean.getSortDirection() == -1) {
            // ascending
            dc.addOrder(Order.asc(searchAuditOmBean.getSortParam()));
        } else {
            // descending
            dc.addOrder(Order.desc(searchAuditOmBean.getSortParam()));
        }
    }

    // if the request didn't come from the pagination area, 
    // it means that I have to set the number of results and pages
    if (isDeleteAction || searchAuditOmBean.getNbrOfResults() == -1) {
        boolean isSearch = false;
        if (searchAuditOmBean.getNbrOfResults() == -1) {
            isSearch = true;
        }
        // set the count(*) restriction         
        dcCount.setProjection(Projections.countDistinct("auditId"));

        //findByCriteria must be called with firstResult and maxResults parameters; the default findByCriteria(DetachedCriteria criteria) implementation
        //sets firstResult and maxResults to -1, which kills the countDistinct Projection         
        int nbrOfResults = ((Integer) getHibernateTemplate().findByCriteria(dcCount, 0, 0).get(0)).intValue();
        logger.debug("search results: ".concat(String.valueOf(nbrOfResults)));
        searchAuditOmBean.setNbrOfResults(nbrOfResults);

        // get the number of pages
        if (nbrOfResults % searchAuditOmBean.getResultsPerPage() == 0) {
            searchAuditOmBean.setNbrOfPages(nbrOfResults / searchAuditOmBean.getResultsPerPage());
        } else {
            searchAuditOmBean.setNbrOfPages(nbrOfResults / searchAuditOmBean.getResultsPerPage() + 1);
        }
        // after an audit is deleted, the same page has to be displayed;
        //only when all the audit events from last page are deleted, the previous page will be shown 
        if (isDeleteAction && (searchAuditOmBean.getCurrentPage() > searchAuditOmBean.getNbrOfPages())) {
            searchAuditOmBean.setCurrentPage(searchAuditOmBean.getNbrOfPages());
        } else if (isSearch) {
            searchAuditOmBean.setCurrentPage(1);
        }

    }

    List<AuditOmBean> res = (List<AuditOmBean>) getHibernateTemplate().findByCriteria(dc,
            (searchAuditOmBean.getCurrentPage() - 1) * searchAuditOmBean.getResultsPerPage(),
            searchAuditOmBean.getResultsPerPage());
    logger.debug("getAuditBeanFromSearch - END results size : ".concat(String.valueOf(res.size())));
    return res;
}

From source file:ro.cs.logaudit.dao.impl.DaoAuditTsImpl.java

License:Open Source License

/**
 * Searches for audit after criterion from searchBean
 * /*from  w w w  .j a  va2s . com*/
 * @author Coni
 * 
 * @return A list of audit beans 
 * @throws ParseException 
 */
public List<AuditTsBean> getAuditBeanFromSearch(SearchAuditTsBean searchAuditTsBean, boolean isDeleteAction,
        Locale locale) throws ParseException {

    logger.debug("getAuditBeanFromSearch - START");

    // set search criterion
    DetachedCriteria dc = DetachedCriteria.forEntityName(IModelConstant.audittsEntity);
    DetachedCriteria dcCount = DetachedCriteria.forEntityName(IModelConstant.audittsEntity);

    if (searchAuditTsBean.getOrganisationId() != -1) {
        dc.add(Restrictions.eq("organisationId", searchAuditTsBean.getOrganisationId()));
        dcCount.add(Restrictions.eq("organisationId", searchAuditTsBean.getOrganisationId()));
    }

    if (searchAuditTsBean.getEvent() != null && !"-1".equals(searchAuditTsBean.getEvent())) {
        dc.add(Restrictions.ilike("event", "%".concat(searchAuditTsBean.getEvent()).concat("%")));
        dcCount.add(Restrictions.ilike("event", "%".concat(searchAuditTsBean.getEvent()).concat("%")));
    }
    if (searchAuditTsBean.getPersonId() != null && !"".equals(searchAuditTsBean.getPersonId())) {
        dc.add(Restrictions.eq("personId", searchAuditTsBean.getPersonId()));
        dcCount.add(Restrictions.eq("personId", searchAuditTsBean.getPersonId()));
    }
    if (searchAuditTsBean.getMessage() != null && !"".equals(searchAuditTsBean.getMessage())) {
        dc.add(Restrictions.ilike("message".concat(locale.toString().toUpperCase()),
                "%".concat(searchAuditTsBean.getMessage()).concat("%")));
        dcCount.add(Restrictions.ilike("message".concat(locale.toString().toUpperCase()),
                "%".concat(searchAuditTsBean.getMessage()).concat("%")));
    }

    if (searchAuditTsBean.getStartDate() != null) {
        dc.add(Expression.ge("date", searchAuditTsBean.getStartDate()));
        dcCount.add(Expression.ge("date", searchAuditTsBean.getStartDate()));
    }

    if (searchAuditTsBean.getEndDate() != null) {
        dc.add(Expression.le("date", searchAuditTsBean.getEndDate()));
        dcCount.add(Expression.le("date", searchAuditTsBean.getEndDate()));
    }

    // check if I have to order the results
    if (searchAuditTsBean.getSortParam() != null && !"".equals(searchAuditTsBean.getSortParam())) {
        // if I have to, check if I have to order them ascending or descending
        if (searchAuditTsBean.getSortDirection() == -1) {
            // ascending
            dc.addOrder(Order.asc(searchAuditTsBean.getSortParam()));
        } else {
            // descending
            dc.addOrder(Order.desc(searchAuditTsBean.getSortParam()));
        }
    }

    // if the request didn't come from the pagination area, 
    // it means that I have to set the number of results and pages
    if (isDeleteAction || searchAuditTsBean.getNbrOfResults() == -1) {
        boolean isSearch = false;
        if (searchAuditTsBean.getNbrOfResults() == -1) {
            isSearch = true;
        }
        // set the count(*) restriction         
        dcCount.setProjection(Projections.countDistinct("auditId"));

        //findByCriteria must be called with firstResult and maxResults parameters; the default findByCriteria(DetachedCriteria criteria) implementation
        //sets firstResult and maxResults to -1, which kills the countDistinct Projection         
        int nbrOfResults = ((Integer) getHibernateTemplate().findByCriteria(dcCount, 0, 0).get(0)).intValue();
        logger.debug("search results: ".concat(String.valueOf(nbrOfResults)));
        searchAuditTsBean.setNbrOfResults(nbrOfResults);

        // get the number of pages
        if (nbrOfResults % searchAuditTsBean.getResultsPerPage() == 0) {
            searchAuditTsBean.setNbrOfPages(nbrOfResults / searchAuditTsBean.getResultsPerPage());
        } else {
            searchAuditTsBean.setNbrOfPages(nbrOfResults / searchAuditTsBean.getResultsPerPage() + 1);
        }
        // after an audit is deleted, the same page has to be displayed;
        //only when all the audit events from last page are deleted, the previous page will be shown 
        if (isDeleteAction && (searchAuditTsBean.getCurrentPage() > searchAuditTsBean.getNbrOfPages())) {
            searchAuditTsBean.setCurrentPage(searchAuditTsBean.getNbrOfPages());
        } else if (isSearch) {
            searchAuditTsBean.setCurrentPage(1);
        }

    }

    List<AuditTsBean> res = (List<AuditTsBean>) getHibernateTemplate().findByCriteria(dc,
            (searchAuditTsBean.getCurrentPage() - 1) * searchAuditTsBean.getResultsPerPage(),
            searchAuditTsBean.getResultsPerPage());
    logger.debug("getAuditBeanFromSearch - END results size : ".concat(String.valueOf(res.size())));
    return res;
}

From source file:ro.cs.om.model.dao.impl.DaoDepartmentImpl.java

License:Open Source License

/**
* Searches for Departments after criterion from searchOrganisationBean.
* 
* @author alu//from www  . j a  v a 2  s  .  com
* @author dan.damian
*/
public List<Department> getFromSearch(SearchDepartmentBean searchDepartmentBean, boolean isDeleteAction)
        throws ParseException {
    logger.debug("getFromSearch - START");
    /*Once a Projection is being set to a Detached Criteria object, it cannot be removed anymore, so two identical DetachedCriteria objects 
    must be created: 
    -dcCount ( on which the projection is being set )used to retrieve the number of distinct results which is set when 
    the request didn't come from the pagination area and needed further more to set the current page after a delete action; 
    -dc used to retrieve the result set after the current page has been set in case of a delete action
    */

    // set search criterion
    DetachedCriteria dc = DetachedCriteria.forEntityName(IModelConstant.departmentAllEntity);
    DetachedCriteria dcCount = DetachedCriteria.forEntityName(IModelConstant.departmentAllEntity);

    dc.createAlias("manager", "manager", Criteria.LEFT_JOIN);
    dcCount.createAlias("manager", "manager", Criteria.LEFT_JOIN);

    if (Tools.getInstance().stringNotEmpty(searchDepartmentBean.getName())) {
        dc.add(Restrictions.ilike("name", "%".concat(searchDepartmentBean.getName()).concat("%")));
        dcCount.add(Restrictions.ilike("name", "%".concat(searchDepartmentBean.getName()).concat("%")));
        logger.debug("name: " + searchDepartmentBean.getName());
    }

    if (searchDepartmentBean.getOrganisationId() != -1) {
        dc.add(Restrictions.eq("organisation.organisationId", searchDepartmentBean.getOrganisationId()));
        dcCount.add(Restrictions.eq("organisation.organisationId", searchDepartmentBean.getOrganisationId()));
        logger.debug("Organisation Id: " + searchDepartmentBean.getOrganisationId());
    }

    if (searchDepartmentBean.getManagerFirstName() != null
            && !"".equals(searchDepartmentBean.getManagerFirstName())) {
        dc.add(Restrictions.eq("manager.firstName", searchDepartmentBean.getManagerFirstName()));
        dcCount.add(Restrictions.eq("manager.firstName", searchDepartmentBean.getManagerFirstName()));
        logger.debug("Manager first name: ".concat(searchDepartmentBean.getManagerFirstName()));
    }

    if (searchDepartmentBean.getManagerLastName() != null
            && !"".equals(searchDepartmentBean.getManagerLastName())) {
        dc.add(Restrictions.eq("manager.lastName", searchDepartmentBean.getManagerLastName()));
        dcCount.add(Restrictions.eq("manager.lastName", searchDepartmentBean.getManagerLastName()));
        logger.debug("Manager last name: ".concat(searchDepartmentBean.getManagerLastName()));
    }

    if (Tools.getInstance().stringNotEmpty(searchDepartmentBean.getParentDepartmentName())) {
        dc.createCriteria("parentDepartment").add(Restrictions.ilike("name",
                "%".concat(searchDepartmentBean.getParentDepartmentName()).concat("%")));
        dcCount.createCriteria("parentDepartment").add(Restrictions.ilike("name",
                "%".concat(searchDepartmentBean.getParentDepartmentName()).concat("%")));
        logger.debug("Parent Department Name: " + searchDepartmentBean.getParentDepartmentName());
    }

    if (searchDepartmentBean.getParentDepartmentId() != -1) {
        dc.add(Restrictions.eq("parentDepartment.departmentId", searchDepartmentBean.getParentDepartmentId()));
        dcCount.add(
                Restrictions.eq("parentDepartment.departmentId", searchDepartmentBean.getParentDepartmentId()));
        logger.debug("Parent Department Id: " + searchDepartmentBean.getParentDepartmentId());
    }

    dc.add(Restrictions.eq("status", IConstant.NOM_DEPARTMENT_ACTIVE));
    dcCount.add(Restrictions.eq("status", IConstant.NOM_DEPARTMENT_ACTIVE));

    // check if I have to order the results
    if (searchDepartmentBean.getSortParam() != null && !"".equals(searchDepartmentBean.getSortParam())) {
        // if I have to, check if I have to order them ascending or descending
        if (searchDepartmentBean.getSortDirection() == -1) {
            // ascending
            dc.addOrder(Order.asc(searchDepartmentBean.getSortParam()));
        } else {
            // descending
            dc.addOrder(Order.desc(searchDepartmentBean.getSortParam()));
        }
    }

    // if the request didn't come from the pagination area, 
    // it means that I have to set the number of result and pages
    if (isDeleteAction || searchDepartmentBean.getNbrOfResults() == -1) {
        boolean isSearch = false;
        if (searchDepartmentBean.getNbrOfResults() == -1) {
            isSearch = true;
        }
        // set the countDistinct restriction
        dcCount.setProjection(Projections.distinct(Projections.countDistinct("departmentId")));

        int nbrOfResults = ((Integer) getHibernateTemplate().findByCriteria(dcCount, 0, 0).get(0)).intValue();
        searchDepartmentBean.setNbrOfResults(nbrOfResults);
        logger.debug("NbrOfResults " + searchDepartmentBean.getNbrOfResults());
        logger.debug("----> searchOrganisationBean.getResults " + searchDepartmentBean.getResultsPerPage());
        // get the number of pages
        if (nbrOfResults % searchDepartmentBean.getResultsPerPage() == 0) {
            searchDepartmentBean.setNbrOfPages(nbrOfResults / searchDepartmentBean.getResultsPerPage());
        } else {
            searchDepartmentBean.setNbrOfPages(nbrOfResults / searchDepartmentBean.getResultsPerPage() + 1);
        }
        // after a department is deleted, the same page has to be displayed;
        //only when all the departments from last page are deleted, the previous page will be shown 
        if (isDeleteAction && (searchDepartmentBean.getCurrentPage() > searchDepartmentBean.getNbrOfPages())) {
            searchDepartmentBean.setCurrentPage(searchDepartmentBean.getNbrOfPages());
        } else if (isSearch) {
            searchDepartmentBean.setCurrentPage(1);
        }
    }

    List<Department> res = getHibernateTemplate().findByCriteria(dc,
            (searchDepartmentBean.getCurrentPage() - 1) * searchDepartmentBean.getResultsPerPage(),
            searchDepartmentBean.getResultsPerPage());

    logger.debug("Res " + res.size());
    logger.debug("getFromSearch - END - results size : ".concat(String.valueOf(res.size())));
    return res;

}

From source file:ro.cs.om.model.dao.impl.DaoDepartmentImpl.java

License:Open Source License

/**
 * Gets the number of departments for an organisation (without the fake departments)
 * /*from w  ww . java  2s.c om*/
 * @author Adelina
 * @parm organisationId
 * @return number of departments from an organisation
 */
@SuppressWarnings("unchecked")
public int getCountDepartments(Integer organisationId) {
    logger.debug("getCountDepartments - START");

    DetachedCriteria dc = DetachedCriteria.forEntityName(IModelConstant.departmentEntity);
    dc.setProjection(Projections.count("departmentId"));
    dc.createCriteria("organisation").add(Restrictions.eq("organisationId", organisationId));
    dc.add(Restrictions.ne("status", (byte) 2));
    List departaments = getHibernateTemplate().findByCriteria(dc);

    logger.debug("getCountDepartments - END - ".concat(String.valueOf(departaments.size())));

    if (departaments != null) {
        int count = ((Integer) departaments.get(0)).intValue();
        logger.debug("count " + count);
        return count;
    } else {
        return 0;
    }
}