customer / shanghai-railway-web

/*
 * @(#)PermissionManagerImpl.java
 *
 * Copyright (c) 2014-2017  xiniunet 版权所有
 * xiniunet. All rights reserved.
 *
 * This software is the confidential and proprietary
 * information of  xiniunet.
 * ("Confidential Information"). You shall not disclose
 * such Confidential Information and shall use it only
 * in accordance with the terms of the contract agreement
 * you entered into with xiniunet.
 */
package com.xiniunet.service.railway.biz;

import com.xiniunet.framework.base.BaseManagerImpl;
import com.xiniunet.framework.base.BaseResponse;
import com.xiniunet.framework.security.Passport;
import com.xiniunet.railway.request.*;
import com.xiniunet.railway.response.*;
import com.xiniunet.railway.domain.*;
import com.xiniunet.service.railway.Message;
import com.xiniunet.service.railway.dal.PermissionLinesMapper;
import com.xiniunet.service.railway.dal.PermissionMapper;
import com.xiniunet.foundation.service.FoundationService;
import com.xiniunet.service.railway.po.PermissionPO;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
import com.xiniunet.framework.exception.ErrorType;


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

/**
 * 选岗权限表的管理方法实现.
 *
 * @author
 */
@Transactional
@Service("RailwayPermissionManager")
public class PermissionManagerImpl extends BaseManagerImpl implements PermissionManager {

    @Autowired
    private FoundationService foundationService;

    @Autowired
    private PermissionMapper permissionMapper;
    @Autowired
    private PermissionStationManager permissionLinesManager;

    /**
     * 根据Id获取选岗权限表
     *
     * @param request  获取选岗权限表请求
     * @param passport 用户护照
     * @return 获取选岗权限表应答
     */
    @Override
    @Transactional(propagation = Propagation.NOT_SUPPORTED, readOnly = true)
    public PermissionGetResponse get(PermissionGetRequest request, Passport passport) {
        PermissionGetResponse response = new PermissionGetResponse();
        PermissionPO entity = permissionMapper.getById(request.getId(), passport);
        if (entity != null) {
            Permission permission = this.getMapper().map(entity, Permission.class);
            response.setPermission(permission);
        } else {
            response.addError(ErrorType.EXPECTATION_NULL, Message.COMMON_GET_FAILURE);
        }
        return response;
    }


    /**
     * 模糊查询选岗权限表
     *
     * @param request  模糊查询选岗权限表请求
     * @param passport 用户护照
     * @return 模糊查询选岗权限表应答
     */
    @Override
    @Transactional(propagation = Propagation.NOT_SUPPORTED, readOnly = true)
    public PermissionSearchResponse search(PermissionSearchRequest request, Passport passport) {
        PermissionSearchResponse response = new PermissionSearchResponse();
        List<Permission> modelList = new ArrayList<>();
        Long count = permissionMapper.searchCount(request, passport);

        if (count > 0) {
            // 处理分页参数
            if (request.getPageSize() > 0) {
                //如果输入的页码大于实际的分页数，将页码设置为最后一页的页码
                int lastPageNumber = (int) ((count - 1) / request.getPageSize() + 1);
                if (request.getPageNumber() > lastPageNumber) {
                    request.setPageNumber(lastPageNumber);
                }
            }

            //通过关键字查询出用户集合
            List<PermissionPO> entityList = permissionMapper.search(request, passport);

            for (PermissionPO entity : entityList) {
                Permission permission = this.getMapper().map(entity, Permission.class);
                modelList.add(permission);
            }
        }

        response.setTotalCount(count);
        response.setResult(modelList);
        return response;
    }

    /**
     * 高级查询选岗权限表
     *
     * @param request  高级查询选岗权限表请求
     * @param passport 用户护照
     * @return 高级查询选岗权限表应答
     */
    @Override
    @Transactional(propagation = Propagation.NOT_SUPPORTED, readOnly = true)
    public PermissionFindResponse find(PermissionFindRequest request, Passport passport) {
        PermissionFindResponse response = new PermissionFindResponse();
        List<Permission> modelList = new ArrayList<>();
        Long count = permissionMapper.findCount(request, passport);
        if (count > 0) {
            // 处理分页参数
            if (request.getPageSize() > 0) {
                //如果输入的页码大于实际的分页数，将页码设置为最后一页的页码
                int lastPageNumber = (int) ((count - 1) / request.getPageSize() + 1);
                if (request.getPageNumber() > lastPageNumber) {
                    request.setPageNumber(lastPageNumber);
                }
            }

            List<PermissionPO> entityList = permissionMapper.find(request, passport);
            for (PermissionPO entity : entityList) {
                Permission permission = this.getMapper().map(entity, Permission.class);
                modelList.add(permission);
            }
        }

        response.setTotalCount(count);
        response.setResult(modelList);
        return response;
    }

    /**
     * 创建选岗权限表
     *
     * @param request  创建选岗权限表请求
     * @param passport 用户护照
     * @return 创建选岗权限表应答
     */
    @Override
    public PermissionCreateResponse create(PermissionCreateRequest request, Passport passport) {
        PermissionCreateResponse response = new PermissionCreateResponse();

        PermissionPO entity = this.getMapper().map(request, PermissionPO.class);
        if (entity.getId() == null) {
            long id = foundationService.getNewId();
            entity.setId(id);
        }

        // 先检查关键数据是否有重复，在检查通过后才能做插入操作
        checkValidate(entity, passport, response);
        if (response.hasError()) {
            return response;
        }

        if (permissionMapper.insert(entity, passport) == 0) {
            response.addError(ErrorType.EXPECTATION_NULL, Message.COMMON_CREATE_FAILURE);
            return response;
        }
        List<PermissionLinesCreateRequest> request1 = new ArrayList<>();
        if (request.getSelectLineList().size() > 0) {
            List<LineStation> lineStations = request.getSelectLineList();
            for (LineStation po : lineStations) {
                PermissionLinesCreateRequest permissionLinesCreate = new PermissionLinesCreateRequest();
                permissionLinesCreate.setPermissionId(entity.getId());
                permissionLinesCreate.setStationId(po.getId());
                permissionLinesCreate.setStationName(po.getName());
                request1.add(permissionLinesCreate);
            }
            permissionLinesManager.createBatch(request1, passport);
        }
        response.setId(entity.getId());
        return response;
    }

    /**
     * 更新选岗权限表
     *
     * @param request  更新选岗权限表请求
     * @param passport 用户护照
     * @return 更新选岗权限表应答
     */
    @Override
    public PermissionUpdateResponse update(PermissionUpdateRequest request, Passport passport) {
        PermissionUpdateResponse response = new PermissionUpdateResponse();

        PermissionPO entity = this.getMapper().map(request, PermissionPO.class);
        // 先检查关键数据是否有重复，在检查通过后才能做插入操作
        checkValidate(entity, passport, response);
        if (response.hasError()) {
            return response;
        }

        Long result = permissionMapper.update(entity, passport);
        if (result != 1) {
            response.addError(ErrorType.BUSINESS_ERROR, Message.COMMON_UPDATE_FAILURE);
            return response;
        }
        PermissionLinesDeleteRequest request1 = new PermissionLinesDeleteRequest();
        request1.setId(entity.getId());
        PermissionLinesDeleteResponse response1 = permissionLinesManager.delete(request1, passport);
        List<PermissionLinesCreateRequest> request2 = new ArrayList<>();
        if (request.getSelectLineList().size() > 0) {
            List<LineStation> lineStations = request.getSelectLineList();
            for (LineStation po : lineStations) {
                PermissionLinesCreateRequest permissionLinesCreate = new PermissionLinesCreateRequest();
                permissionLinesCreate.setPermissionId(entity.getId());
                permissionLinesCreate.setStationId(po.getId());
                permissionLinesCreate.setStationName(po.getName());
                request2.add(permissionLinesCreate);
            }
            permissionLinesManager.createBatch(request2, passport);
        }
        response.setResult(result);
        return response;
    }

    /**
     * 删除选岗权限表
     *
     * @param request  删除选岗权限表请求
     * @param passport 用户护照
     * @return 删除选岗权限表应答
     */
    @Override
    public PermissionDeleteResponse delete(PermissionDeleteRequest request, Passport passport) {
        PermissionDeleteResponse response = new PermissionDeleteResponse();
        Long result = permissionMapper.delete(request.getId(), passport);
        response.setResult(result);
        return response;
    }

    /**
     * 所有权限
     *
     * @param passport
     * @return
     */
    @Override
    public PermissionFindResponse findAllPermissionList(Passport passport) {
        PermissionFindResponse response = new PermissionFindResponse();
        List<Permission> modelList = new ArrayList<>();
        List<PermissionPO> entityList = permissionMapper.getAllList(passport);
        for (PermissionPO entity : entityList) {
            Permission permission = this.getMapper().map(entity, Permission.class);
            modelList.add(permission);
        }
        response.setResult(modelList);
        return response;
    }

    /**
     * 根据名称账号查询权限
     *
     * @param request
     * @param passport 用户护照
     * @return
     */
    @Override
    public PermissionFindResponse findPermissionByNameList(PermissionFindRequest request, Passport passport) {
        PermissionFindResponse response = new PermissionFindResponse();
        List<Permission> modelList = new ArrayList<>();
        List<PermissionPO> entityList = permissionMapper.findPermissionByNameList(request.getNameList(), passport);
        for (PermissionPO entity : entityList) {
            Permission permission = this.getMapper().map(entity, Permission.class);
            modelList.add(permission);
        }

        response.setResult(modelList);
        return response;
    }

    /**
     * 验证对象
     *
     * @param permission 选岗权限表
     * @param passport   用户护照
     */
    private void checkValidate(PermissionPO permission, Passport passport, BaseResponse response) {
        // TODO
    }
}