com.kingen.service.org.OrgService.java Source code

Introduction

Here is the source code for com.kingen.service.org.OrgService.java

Source

/*******************************************************************************
 * Copyright (c) 2005, 2014 springside.github.io
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 *******************************************************************************/
package com.kingen.service.org;

import java.util.List;

import org.activiti.engine.IdentityService;
import org.apache.commons.lang3.builder.ToStringBuilder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.Assert;
import org.springframework.util.CollectionUtils;

import com.kingen.aop.ServiceLogAnnotation;
import com.kingen.bean.SysOrg;
import com.kingen.bean.SysUserOrg;
import com.kingen.bean.SysUserOrgId;
import com.kingen.bean.User;
import com.kingen.repository.account.UserDao;
import com.kingen.repository.activiti.ActivitiDao;
import com.kingen.repository.org.OrgDao;
import com.kingen.util.Page;

/**
 * ?.
 * 
 */
// Spring Service Bean.
@Component
@Transactional
public class OrgService {

    public static final String HASH_ALGORITHM = "SHA-1";
    public static final int HASH_INTERATIONS = 1024;
    private static final int SALT_SIZE = 8;

    private static Logger logger = LoggerFactory.getLogger(OrgService.class);

    @Autowired
    private OrgDao dao;
    @Autowired
    private UserDao userDao;
    @Autowired
    private ActivitiDao activitiDao;

    @ServiceLogAnnotation(action = "?")
    public void create(SysOrg obj, Boolean synToActiviti) {
        dao.save(obj);

        // ??Activiti Identify?
        if (synToActiviti) {

            saveActivitiGroup(obj);
        }

    }

    @ServiceLogAnnotation(action = "")
    public void update(SysOrg SysOrg, Boolean synToActiviti) {
        dao.update(SysOrg);
        // ??Activiti Identify?
        if (synToActiviti) {

            saveActivitiGroup(SysOrg);
        }

    }

    @ServiceLogAnnotation(action = "")
    public void delOrgUsers(String orgId, List<String> userIds, Boolean synToActiviti) {

        Assert.hasLength(orgId, "ID?");
        Assert.notEmpty(userIds, "ID?");
        dao.delOrgUsers(orgId, userIds);
        // ??Activiti Identify?
        if (synToActiviti) {

            for (String userId : userIds) {
                identityService.deleteMembership(userId, orgId);
            }

        }

    }

    @ServiceLogAnnotation(action = "")
    public void delOrg(String orgId, Boolean synToActiviti) {

        Assert.hasLength(orgId, "ID?");

        dao.delOrg(orgId);

        if (synToActiviti) {
            identityService.deleteGroup(orgId);
        }

    }

    @ServiceLogAnnotation(action = "?")
    public void saveOrgUser(String orgId, String userId) throws Exception {
        if (orgId != null) {
            SysUserOrgId userOrgId = new SysUserOrgId(userId, orgId);
            SysUserOrg u = new SysUserOrg(userOrgId);
            dao.saveme(u);
        }
    }

    @ServiceLogAnnotation(action = "?")
    public void saveOrgUsers(String orgId, List<String> userIds, Boolean synToActiviti) throws Exception {
        if (orgId != null) {
            Assert.notEmpty(userIds);
            for (String userId : userIds) {
                SysUserOrgId userOrgId = new SysUserOrgId(userId, orgId);
                SysUserOrg u = new SysUserOrg(userOrgId);
                dao.saveme(u);

                if (synToActiviti) {
                    identityService.createMembership(userId, orgId);
                }
            }
        }
    }

    public SysOrg one(SysOrg o) {

        return dao.findByPK(o.getId());
    }

    public Page<SysOrg> getOrgs(Page<SysOrg> page, SysOrg object) {
        Page<SysOrg> p = dao.findOrgs(page, object);
        return p;
    }

    public Page<User> getOrgUsers(Page<User> page, String orgId) {
        Page<User> p = userDao.findOrgUsers(page, orgId);
        return p;
    }

    public Page<User> getOrgUsersRemain(Page<User> page, String orgId) {
        Page<User> p = userDao.findOrgUsersRemain(page, orgId);
        return p;
    }

    //? 
    @Autowired
    protected IdentityService identityService;

    /**
    * /  Activiti {@link org.activiti.engine.identity.User}
    * @param user  , {@link User}
    */
    //private ??
    private void saveActivitiGroup(SysOrg org) {
        org.activiti.engine.identity.Group group = identityService.createGroupQuery().groupId(org.getId())
                .singleResult();
        if (group == null) {
            group = identityService.newGroup(org.getId());
        }
        group.setName(org.getName());
        group.setType("");
        identityService.saveGroup(group);
        logger.info("add activiti user: {}" + ToStringBuilder.reflectionToString(group));
    }

    public void synAllUserAndGroupToActiviti() throws Exception {
        // ???
        deleteAllActivitiIdentifyData();

        // ??
        synOrgToActiviti();

        // ???
        synUserWithRoleToActiviti();

    }

    public void deleteAllActivitiIdentifyData() throws Exception {
        activitiDao.deleteAllMemerShip();
        activitiDao.deleteAllGroup();
        activitiDao.deleteAllUser();
    }

    /**
    * ??{@link Group}
     * @throws Exception 
    */
    private void synOrgToActiviti() throws Exception {
        List<SysOrg> allGroup = dao.find();
        for (SysOrg group : allGroup) {
            String groupId = group.getId().toString();
            org.activiti.engine.identity.Group identity_group = identityService.newGroup(groupId);
            identity_group.setName(group.getName());
            identity_group.setType("");
            identityService.saveGroup(identity_group);
        }
    }

    /**
    * ???
    * @throws Exception 
    */
    private void synUserWithRoleToActiviti() throws Exception {
        List<User> allUser = userDao.find();
        for (User user : allUser) {
            String userId = user.getUserId().toString();
            // Activiti
            saveActivitiUser(user);

            List<SysUserOrg> memberShips = dao.findSysUserOrgs(userId);

            if (!CollectionUtils.isEmpty(memberShips)) {
                for (SysUserOrg suo : memberShips) {
                    // 
                    identityService.createMembership(userId, suo.getId().getOrgId());
                }

            }

        }
    }

    //private ??
    private void saveActivitiUser(User user) {
        org.activiti.engine.identity.User activitiUser = identityService.createUserQuery().userId(user.getUserId())
                .singleResult();
        if (activitiUser == null) {
            activitiUser = identityService.newUser(user.getUserId());
        }
        activitiUser.setFirstName(user.getUsername());
        activitiUser.setLastName(user.getUsername());
        activitiUser.setEmail("");
        activitiUser.setPassword(user.getPassword());
        identityService.saveUser(activitiUser);
        logger.info("add activiti user: {}" + ToStringBuilder.reflectionToString(activitiUser));
    }
}