com.nec.harvest.service.impl.MenuGroupServiceImpl.java Source code

Introduction

Here is the source code for com.nec.harvest.service.impl.MenuGroupServiceImpl.java

Source

/**
 * Copyright(C) 2014
 * NEC Corporation All rights reserved.
 * 
 * No permission to use, copy, modify and distribute this software
 * and its documentation for any purpose is granted.
 * This software is provided under applicable license agreement only.
 */
package com.nec.harvest.service.impl;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

import org.apache.commons.collections.CollectionUtils;
import org.apache.commons.lang.StringUtils;
import org.hibernate.Criteria;
import org.hibernate.HibernateException;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.Transaction;
import org.hibernate.criterion.Criterion;
import org.hibernate.criterion.Restrictions;
import org.hibernate.transform.Transformers;

import com.nec.core.exception.ObjectNotFoundException;
import com.nec.crud.hibernate.HibernateSessionManager;
import com.nec.harvest.bean.mapping.ProcessGroupBean;
import com.nec.harvest.exception.ServiceException;
import com.nec.harvest.model.MenuH;
import com.nec.harvest.repository.MenuRepository;
import com.nec.harvest.repository.SubMenuRepository;
import com.nec.harvest.service.MenuGroupService;

/**
 * {@link MenuGroupService}
 * 
 * @author sondn
 * @version MenuGroupServiceImpl.java Jun 1, 2014
 *
 */
public class MenuGroupServiceImpl implements MenuGroupService {

    private MenuRepository repository;

    @SuppressWarnings("unused")
    private SubMenuRepository subMenuRepository;

    public MenuGroupServiceImpl(MenuRepository menuRepository, SubMenuRepository subMenuRepository) {
        this.repository = menuRepository;
        this.subMenuRepository = subMenuRepository;
    }

    /** {@inheritDoc} */
    @Override
    public List<MenuH> findByUserRole(String userRole) throws ServiceException {
        if (StringUtils.isEmpty(userRole)) {
            throw new IllegalArgumentException("User's role must not be empty or empty");
        }

        final Session session = HibernateSessionManager.getSession();
        Transaction tx = null;

        List<MenuH> menuGroups = new ArrayList<>();
        try {
            tx = session.beginTransaction();
            Criterion criterion = Restrictions.and(Restrictions.eq("proKGCode", userRole),
                    Restrictions.eq("proGEnable", "T"));
            Criteria criteria = repository.getCriteria(session, MenuH.class);
            criteria.add(criterion);
            menuGroups = repository.findByCriteria(criteria);
            if (CollectionUtils.isEmpty(menuGroups)) {
                throw new ObjectNotFoundException("Could not find any menu group matches with role " + userRole);
            }
            for (MenuH group : menuGroups) {
                // Sorting MenuD Object on natural order - ascending (ASC)
                Collections.sort(group.getChildren());
            }
            tx.commit();
        } catch (HibernateException ex) {
            if (tx != null) {
                tx.rollback();
            }
            throw new ServiceException("An error occurred when getting menu groups for role " + userRole, ex);
        } finally {
            HibernateSessionManager.closeSession(session);
        }
        return menuGroups;
    }

    /** {@inheritDoc} */
    @Override
    public boolean hasMenuGroupByUserRoleAndSpecificGroup(String userRole, String specificGroup)
            throws ServiceException {
        final Session session = HibernateSessionManager.getSession();
        Transaction tx = null;

        boolean hasMenuGroup = Boolean.FALSE;
        try {
            tx = session.beginTransaction();
            Criteria criteria = repository.getCriteria(session, MenuH.class);
            // ??
            // 1?2?3??4
            if (StringUtils.isNotEmpty(userRole)) {
                criteria.add(Restrictions.eq("proKGCode", userRole));
            }

            // ?? 001999
            if (StringUtils.isNotEmpty(specificGroup)) {
                criteria.add(Restrictions.eq("proGNo", specificGroup));
            }

            // ? T: F:
            criteria.add(Restrictions.eq("proGEnable", "T"));
            List<MenuH> menuGroups = repository.findByCriteria(criteria);
            if (CollectionUtils.isNotEmpty(menuGroups)) {
                hasMenuGroup = true;
            }
            tx.commit();
        } catch (HibernateException ex) {
            if (tx != null) {
                tx.rollback();
            }
            throw new ServiceException("An error occurred when getting menu groups for role " + userRole
                    + " and specific group " + specificGroup, ex);
        } finally {
            HibernateSessionManager.closeSession(session);
        }
        return hasMenuGroup;
    }

    /** {@inheritDoc} */
    @Override
    @SuppressWarnings("unchecked")
    public List<ProcessGroupBean> findAllGroups() throws ServiceException {
        final Session session = HibernateSessionManager.getSession();
        Transaction tx = null;

        List<ProcessGroupBean> processGroupBeans = new ArrayList<>();
        try {
            tx = session.beginTransaction();
            Query query = repository
                    .getQuery(session,
                            "SELECT a.proGName FROM AT108 a GROUP BY a.proGName ORDER BY a.proGName DESC")
                    .setResultTransformer(Transformers.aliasToBean(ProcessGroupBean.class));
            processGroupBeans = query.list();
            tx.commit();
        } catch (HibernateException ex) {
            if (tx != null) {
                tx.rollback();
            }
            throw new ServiceException("An error occurred when getting all groups", ex);
        } finally {
            HibernateSessionManager.closeSession(session);
        }
        return processGroupBeans;
    }

}