customer / shanghai-railway-web

/*
 * @(#)EventManagerImpl.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.foundation.service.FoundationService;
import com.xiniunet.framework.base.BaseManagerImpl;
import com.xiniunet.framework.base.BaseResponse;
import com.xiniunet.framework.exception.ErrorType;
import com.xiniunet.framework.security.Passport;
import com.xiniunet.railway.domain.Event;
import com.xiniunet.railway.domain.EventUser;
import com.xiniunet.railway.request.*;
import com.xiniunet.railway.response.*;
import com.xiniunet.service.railway.Message;
import com.xiniunet.service.railway.dal.EventMapper;
import com.xiniunet.service.railway.po.EventCountPO;
import com.xiniunet.service.railway.po.EventPO;
import com.xiniunet.service.railway.po.EventUserPO;
import com.xiniunet.service.railway.util.DateTool;
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 java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.List;
import java.util.logging.SimpleFormatter;

/**
 * 事件的管理方法实现.
 *
 * @author xiniunet
 */
@Transactional
@Service("RailwayEventManager")
public class EventManagerImpl extends BaseManagerImpl implements EventManager {

    @Autowired
    private FoundationService foundationService;

    @Autowired
    private EventMapper eventMapper;

    /**
     * 根据Id获取事件
     *
     * @param request  获取事件请求
     * @param passport 用户护照
     * @return 获取事件应答
     */
    @Override
    @Transactional(propagation = Propagation.NOT_SUPPORTED, readOnly = true)
    public EventGetResponse get(EventGetRequest request, Passport passport) {
        EventGetResponse response = new EventGetResponse();
        EventPO entity = eventMapper.getById(request.getId(), passport);
        if (entity != null) {
            Event event = this.getMapper().map(entity, Event.class);
            response.setEvent(event);
        } else {
            response.addError(ErrorType.EXPECTATION_NULL, Message.COMMON_GET_FAILURE);
        }
        return response;
    }
    /**
     * 根事件Id获取事件
     *
     * @param request  获取事件请求
     * @param passport 用户护照
     * @return 获取事件应答
     */
    @Override
    @Transactional(propagation = Propagation.NOT_SUPPORTED, readOnly = true)
    public EventGetResponse getByEventId(EventGetByEventIdRequest request, Passport passport) {
        EventGetResponse response = new EventGetResponse();
        EventPO entity = eventMapper.getByEventId(request.getEventId(), passport);
        if (entity != null) {
            Event event = this.getMapper().map(entity, Event.class);
            response.setEvent(event);
        } 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 EventSearchResponse search(EventSearchRequest request, Passport passport) {
        EventSearchResponse response = new EventSearchResponse();
        List<Event> modelList = new ArrayList<>();
        Long count = eventMapper.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<EventPO> entityList = eventMapper.search(request, passport);

            for (EventPO entity : entityList) {
                Event event = this.getMapper().map(entity, Event.class);
                modelList.add(event);
            }
        }

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

    /**
     * 高级查询事件
     *
     * @param request  高级查询事件请求
     * @param passport 用户护照
     * @return 高级查询事件应答
     */
    @Override
    @Transactional(propagation = Propagation.NOT_SUPPORTED, readOnly = true)
    public EventFindResponse find(EventFindRequest request, Passport passport) {
        EventFindResponse response = new EventFindResponse();
        List<Event> modelList = new ArrayList<>();
        Long count = eventMapper.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<EventPO> entityList = eventMapper.find(request, passport);
            for (EventPO entity : entityList) {
                Event event = this.getMapper().map(entity, Event.class);
                modelList.add(event);
            }
        }

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

    /**
     * 创建事件
     *
     * @param request  创建事件请求
     * @param passport 用户护照
     * @return 创建事件应答
     */
    @Override
    public EventCreateResponse create(EventCreateRequest request, Passport passport) {
        EventCreateResponse response = new EventCreateResponse();

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

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

        if (eventMapper.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 EventUpdateResponse update(EventUpdateRequest request, Passport passport) {
        EventUpdateResponse response = new EventUpdateResponse();

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

        Long result = eventMapper.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 EventDeleteResponse delete(EventDeleteRequest request, Passport passport) {
        EventDeleteResponse response = new EventDeleteResponse();
        Long result = eventMapper.delete(request.getId(), passport);
        response.setResult(result);
        return response;
    }


    /**
     * 验证对象
     *
     * @param event    事件
     * @param passport 用户护照
     */
    private void checkValidate(EventPO event, Passport passport, BaseResponse response) {
        // TODO
    }

    /**
     * 更新事件(第三方回调)
     *
     * @param request  更新事件请求
     * @param passport 用户护照
     * @return 更新事件应答
     */
    @Override
    public EventUpdateResponse updateEvent(EventUpdateRequest request, Passport passport) {
        EventUpdateResponse response = new EventUpdateResponse();
        EventPO entity = this.getMapper().map(request, EventPO.class);
        // 先检查关键数据是否有重复，在检查通过后才能做插入操作
        checkValidate(entity, passport, response);
        if (response.hasError()) {
            return response;
        }

        Long result = eventMapper.updateEvent(entity, passport);
        if (result != 1) {
            response.addError(ErrorType.BUSINESS_ERROR, Message.COMMON_UPDATE_FAILURE);
            return response;
        }
        response.setResult(result);
        return response;
    }

    /**
     * 根据用户ID查询事件
     *
     * @param request  高级查询事件请求
     * @param passport 用户护照
     * @return 高级查询事件应答
     */
    @Override
    public EventFindByUserIdResponse getCountByUserId(EventFindByUserIdRequest request, Passport passport){
        EventFindByUserIdResponse response = new EventFindByUserIdResponse();
        EventCountPO eventCountPO = eventMapper.getCountByUserId(request, passport);
        response = this.getMapper().map(eventCountPO,response.getClass());
        return response;
    }

    /**
     * 我的事件
     * @param request
     * @param passport
     * @return
     */
    @Override
    public MyEventFindResponse findMyEvent(MyEventRequest request, Passport passport){
        MyEventFindResponse response = new MyEventFindResponse();
        Long userId = request.getUserId();
        List<EventPO> event = eventMapper.getListByUserId(userId,passport);
        List<Event> modelList = new ArrayList<>();
        if (event.size() > 0) {
            for (EventPO entity : event) {
                Event event1 = this.getMapper().map(entity, Event.class);
                if (event1.getAppAttachementAddress3() != null){
                    String[] address = new String[3];
                    address[0] = event1.getAppAttachementAddress1();
                    address[1] = event1.getAppAttachementAddress2();
                    address[2] = event1.getAppAttachementAddress3();
                    event1.setAppAttachementAddress(address);
                }else if (event1.getAppAttachementAddress2() != null){
                    String[] address = new String[2];
                    address[0] = event1.getAppAttachementAddress1();
                    address[1] = event1.getAppAttachementAddress2();
                    event1.setAppAttachementAddress(address);
                }else if (event1.getAppAttachementAddress1() != null){
                    String[] address = new String[1];
                    address[0] = event1.getAppAttachementAddress1();
                    event1.setAppAttachementAddress(address);
                }
                modelList.add(event1);
            }
        }
        response.setResult(modelList);
        return response;
    }

    @Override
    public EventFindByConditionResponse findEventByCondition(EventFindByConditionRequest request, Passport passport) {
        EventFindByConditionResponse response = new EventFindByConditionResponse();
        List<EventUser> modelList = new ArrayList<>();
        String type = request.getType();
        if (type != "") {
            switch (type){
                case "车站事件" :
                    type = "STATION";
                    break;
                case "车厢事件" :
                    type = "CARRIAGE";
                    break;
                case "好人好事" :
                    type = "GOOD";
                    break;
            }
        }
        request.setType(type);
        Long count = eventMapper.searchEventCount(request, passport);
        if (count > 0) {
            // 处理分页参数
            if (request.getPageSize() > 0) {
                //如果输入的页码大于实际的分页数，将页码设置为最后一页的页码
                int lastPageNumber = (int) ((count - 1) / request.getPageSize() + 1);
                if (request.getPageNumber() > lastPageNumber) {
                    request.setPageNumber(lastPageNumber);
                }
            }
            request.setRequestIndex((long) request.getPageSize()*(request.getPageNumber()-1));

            List<EventUserPO> entityList = eventMapper.findEventByCondition(request,passport);
            for (EventUserPO entity : entityList) {
                EventUser eventUser = this.getMapper().map(entity, EventUser.class);
                modelList.add(eventUser);
            }
        }

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