customer / shanghai-railway-web

/*
 * @(#)PermissionLinesManagerImpl.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.service.railway.po.LinesStationsPO;
import com.xiniunet.service.railway.po.PermissionLinesPO;
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.HashMap;
import java.util.List;
import java.util.Map;

/**
 * 权限线路对应表的管理方法实现.
 * @author 
 */
@Transactional
@Service("RailwayPermissionLinesManager")
public class PermissionStationManagerImpl extends BaseManagerImpl implements PermissionStationManager {

    @Autowired
    private FoundationService foundationService;

    @Autowired
    private PermissionLinesMapper permissionLinesMapper;
    @Autowired
    private PermissionMapper permissionMapper;
    /**
     * 根据Id获取权限线路对应表
     *
     * @param request 获取权限线路对应表请求
     * @param passport 用户护照
     * @return 获取权限线路对应表应答
     */
    @Override
    @Transactional(propagation = Propagation.NOT_SUPPORTED, readOnly = true)
    public PermissionLinesGetResponse get(PermissionLinesGetRequest request, Passport passport) {
        PermissionLinesGetResponse response = new PermissionLinesGetResponse();
        PermissionLinesPO entity = permissionLinesMapper.getById(request.getId(), passport);
        if (entity != null) {
            PermissionLines permissionLines = this.getMapper().map(entity, PermissionLines.class);
            response.setPermissionLines(permissionLines );
        } 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 PermissionLinesSearchResponse search(PermissionLinesSearchRequest request, Passport passport) {
        PermissionLinesSearchResponse response = new PermissionLinesSearchResponse();
        List<PermissionLines> modelList = new ArrayList<>();
        Long count = permissionLinesMapper.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<PermissionLinesPO> entityList = permissionLinesMapper.search(request, passport);
    
            for (PermissionLinesPO entity : entityList) {
                PermissionLines permissionLines = this.getMapper().map(entity, PermissionLines.class);
                modelList.add(permissionLines);
            }
        }
    
        response.setTotalCount(count);
        response.setResult(modelList);
        return response;
    }
    
    /**
     * 高级查询权限线路对应表
     *
     * @param request 高级查询权限线路对应表请求
     * @param passport 用户护照
     * @return 高级查询权限线路对应表应答
     */
    @Override
    @Transactional(propagation = Propagation.NOT_SUPPORTED, readOnly = true)
    public PermissionLinesFindResponse find(PermissionLinesFindRequest request, Passport passport) {
        PermissionLinesFindResponse response = new PermissionLinesFindResponse();
        List<PermissionLines> modelList = new ArrayList<>();
        Long count = permissionLinesMapper.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<PermissionLinesPO> entityList = permissionLinesMapper.find(request, passport);
            for (PermissionLinesPO entity : entityList) {
                PermissionLines permissionLines = this.getMapper().map(entity, PermissionLines.class);
                modelList.add(permissionLines);
            }
        }
    
        response.setTotalCount(count);
        response.setResult(modelList);
        return response;
    }
    
    /**
     * 创建权限线路对应表
     *
     * @param request 创建权限线路对应表请求
     * @param passport 用户护照
     * @return 创建权限线路对应表应答
     */
    @Override
    public PermissionLinesCreateResponse create(PermissionLinesCreateRequest request, Passport passport) {
        PermissionLinesCreateResponse response = new PermissionLinesCreateResponse();

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

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

        if (permissionLinesMapper.insert(entity, passport) == 0) {
            response.addError(ErrorType.EXPECTATION_NULL, Message.COMMON_CREATE_FAILURE);
            return response;
        }

        response.setId(entity.getId());
        return response;
    }

    /**
     * 批量创建权限线路对应表
     *
     * @param request 创建权限线路对应表请求
     * @param passport 用户护照
     * @return 创建权限线路对应表应答
     */
    @Override
    public PermissionLinesCreateResponse createBatch(List<PermissionLinesCreateRequest> request, Passport passport) {
        PermissionLinesCreateResponse response = new PermissionLinesCreateResponse();

        List<PermissionLinesPO> permissionLinesPOS = new ArrayList<>();
        for (PermissionLinesCreateRequest request1 : request){

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

            // 先检查关键数据是否有重复，在检查通过后才能做插入操作
            checkValidate(entity,passport,response);
            if(response.hasError()) {
                return response;
            }
            permissionLinesPOS.add(entity);
        }
        permissionLinesMapper.insertBatch(permissionLinesPOS, passport);
        /*if (permissionLinesMapper.insertBatch(permissionLinesPOS, passport) == 0) {
            response.addError(ErrorType.EXPECTATION_NULL, Message.COMMON_CREATE_FAILURE);
            return response;
        }*/
        return response;
    }

    /**
     * 更新权限线路对应表
     *
     * @param request 更新权限线路对应表请求
     * @param passport 用户护照
     * @return 更新权限线路对应表应答
     */
    @Override
public PermissionLinesUpdateResponse update(PermissionLinesUpdateRequest request, Passport passport) {
        PermissionLinesUpdateResponse response = new PermissionLinesUpdateResponse();

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

        Long result=permissionLinesMapper.update(entity, passport);
        if (result != 1) {
            response.addError(ErrorType.BUSINESS_ERROR, Message.COMMON_UPDATE_FAILURE);
            return response;
        }
        response.setResult(result);
        return response;
    }
    
    /**
     * 删除权限线路对应表
     *
     * @param request 删除权限线路对应表请求
     * @param passport 用户护照
     * @return 删除权限线路对应表应答
     */
    @Override
    public PermissionLinesDeleteResponse delete(PermissionLinesDeleteRequest request, Passport passport) {
        PermissionLinesDeleteResponse response = new PermissionLinesDeleteResponse();
         Long result= permissionLinesMapper.delete(request.getId(), passport);
         response.setResult(result);
        return response;
    }
    
    

    /**
     * 验证对象
     * @param permissionLines 权限线路对应表
     * @param passport 用户护照
     */
    private void checkValidate(PermissionLinesPO permissionLines, Passport passport, BaseResponse response) {
        // TODO
    }

    /**
     * 地铁站台表
     * @param request
     * @param passport
     * @return
     */
    @Override
    public LineStationFindResponse findRailwayLineStation(LineStationFindRequest request, Passport passport){
        LineStationFindResponse response = new LineStationFindResponse();
        List<LineStation> modelList = new ArrayList<>();
        List<LinesStationsPO> linesStationsPO = permissionLinesMapper.findStation(request,passport);
        for (LinesStationsPO entity : linesStationsPO) {
            LineStation lineStation = this.getMapper().map(entity, LineStation.class);
            modelList.add(lineStation);
        }
        response.setLineList(modelList);
        return response;
    }

    /**
     * 权限编辑查询
     * @param request
     * @param passport
     * @return
     */
    @Override
    public RailwayPermissionFindResponse findRailwayPermission(RailwayPermissionFindRequest request, Passport passport){
        RailwayPermissionFindResponse response = new RailwayPermissionFindResponse();
        LineStationFindRequest request1 = new LineStationFindRequest();
        //全部地铁站台信息
        LineStationFindResponse response1 = this.findRailwayLineStation(request1,passport);

        //已选择的站台
        List<LineStation> modelList = new ArrayList<>();
        List<LinesStationsPO> linesStationsPO = permissionLinesMapper.findSelectedStation(request,passport);
        Map<String,LineStation> lineStationMap = new HashMap<>();
        for (LinesStationsPO entity : linesStationsPO) {
            LineStation lineStation = this.getMapper().map(entity, LineStation.class);
            lineStationMap.put(lineStation.getId(),lineStation);
            modelList.add(lineStation);
        }
        response.setSelectLineList(modelList);

        if (modelList.size() > 0 && modelList != null) {
            List<LineStation> lineStations = response1.getLineList();
            List<LineStation> list = new ArrayList<>();
            for (LineStation lineStation : lineStations) {
                if (!lineStationMap.containsKey(lineStation.getId())) {
                    list.add(lineStation);
                }
            }
            response.setLineList(list);
        }else {
            response.setLineList(response1.getLineList());
        }
        PermissionPO entity = permissionMapper.findPermission(request, passport);
        response.setName(entity.getName());
        response.setDescription(entity.getDescription());
        response.setId(entity.getId());
        return response;
    }
}