customer / shanghai-railway-web

/*
 * @(#)SignPointsManagerImpl.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.master.request.membership.MemberGetByUserIdRequest;
import com.xiniunet.master.response.membership.MemberGetByUserIdResponse;
import com.xiniunet.master.service.MasterService;
import com.xiniunet.membership.domain.SourceTypeEnum;
import com.xiniunet.membership.request.PointAddRequest;
import com.xiniunet.membership.response.PointAddResponse;
import com.xiniunet.membership.service.MembershipService;
import com.xiniunet.railway.request.*;
import com.xiniunet.railway.response.*;
import com.xiniunet.railway.domain.*;
import com.xiniunet.foundation.service.FoundationService;
import com.xiniunet.service.railway.Message;
import com.xiniunet.service.railway.dal.SignPointsMapper;
import com.xiniunet.service.railway.po.SignPointsPO;
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 org.springframework.transaction.interceptor.TransactionAspectSupport;


import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;

/**
 * 的管理方法实现.
 * @author 
 */
@Transactional
@Service("RailwaySignPointsManager")
public class SignPointsManagerImpl extends BaseManagerImpl implements SignPointsManager {

    @Autowired
    private FoundationService foundationService;

    @Autowired
    private SignPointsMapper signPointsMapper;
    @Autowired
    private MembershipService membershipService;
    @Autowired
    private MasterService masterService;

    /**
     * 根据Id获取
     *
     * @param request 获取请求
     * @param passport 用户护照
     * @return 获取应答
     */
    @Override
    @Transactional(propagation = Propagation.NOT_SUPPORTED, readOnly = true)
    public SignPointsGetResponse get(SignPointsGetRequest request, Passport passport) {
        SignPointsGetResponse response = new SignPointsGetResponse();
        SignPointsPO entity = signPointsMapper.getById(request.getId(), passport);
        if (entity != null) {
            SignPoints signPoints = this.getMapper().map(entity, SignPoints.class);
            response.setSignPoints(signPoints );
        } else {
            SignPoints signPoints = new SignPoints();
            signPoints.setUserId(request.getId());
            signPoints.setDayNum(0);
            response.setSignPoints(signPoints );
            /*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 SignPointsSearchResponse search(SignPointsSearchRequest request, Passport passport) {
        SignPointsSearchResponse response = new SignPointsSearchResponse();
        List<SignPoints> modelList = new ArrayList<>();
        Long count = signPointsMapper.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<SignPointsPO> entityList = signPointsMapper.search(request, passport);
    
            for (SignPointsPO entity : entityList) {
                SignPoints signPoints = this.getMapper().map(entity, SignPoints.class);
                modelList.add(signPoints);
            }
        }
    
        response.setTotalCount(count);
        response.setResult(modelList);
        return response;
    }
    
    /**
     * 高级查询
     *
     * @param request 高级查询请求
     * @param passport 用户护照
     * @return 高级查询应答
     */
    @Override
    @Transactional(propagation = Propagation.NOT_SUPPORTED, readOnly = true)
    public SignPointsFindResponse find(SignPointsFindRequest request, Passport passport) {
        SignPointsFindResponse response = new SignPointsFindResponse();
        List<SignPoints> modelList = new ArrayList<>();
        Long count = signPointsMapper.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<SignPointsPO> entityList = signPointsMapper.find(request, passport);
            for (SignPointsPO entity : entityList) {
                SignPoints signPoints = this.getMapper().map(entity, SignPoints.class);
                modelList.add(signPoints);
            }
        }
    
        response.setTotalCount(count);
        response.setResult(modelList);
        return response;
    }
    
    /**
     * 创建
     *
     * @param request 创建请求
     * @param passport 用户护照
     * @return 创建应答
     */
    @Override
    public SignPointsCreateResponse create(SignPointsCreateRequest request, Passport passport) {
        SignPointsCreateResponse response = new SignPointsCreateResponse();

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

        // 先检查关键数据是否有重复，在检查通过后才能做插入操作
        checkValidate(entity,passport,response);
        if(response.hasError()) {
            return response;
        }
        SignPointsGetRequest request1 = new SignPointsGetRequest();
        request1.setId(request.getUserId());
        SignPointsGetResponse response1 = this.get(request1,passport);
        SignPoints signPoints = response1.getSignPoints();
        Date now = new Date();
        SimpleDateFormat myFmt1=new SimpleDateFormat("yyyyMMdd");
        String nowId=myFmt1.format(now);
        entity.setDateId(Long.valueOf(nowId));
        MemberGetByUserIdRequest memberGetRequest = new MemberGetByUserIdRequest();
        memberGetRequest.setUserId(request.getUserId());
        MemberGetByUserIdResponse memberGetByUserIdResponse =masterService.getMemberByUserId(memberGetRequest,passport);
        PointAddRequest pointAddRequest = new PointAddRequest();
        if(memberGetByUserIdResponse.getResult() != null && memberGetByUserIdResponse.getResult().size()>0) {
            if (signPoints != null) {
                if (signPoints.getDateId() != null && nowId.equals(signPoints.getDateId().toString())) {
                    response.addError(ErrorType.BUSINESS_ERROR, "今日已签到");
                    return response;
                } else {
                    Long nowDate = Long.valueOf(nowId) - 1;
                    if (signPoints.getDateId() != null && signPoints.getDateId().equals(nowDate)) {//连续签到
                        pointAddRequest.setMemberId(memberGetByUserIdResponse.getResult().get(0).getId());
                        Integer points = signPoints.getDayNum() > 4 ? 20 : 5 * signPoints.getDayNum();
                        pointAddRequest.setPoint(points);
                        pointAddRequest.setSourceId(entity.getId());
                        pointAddRequest.setSummary("签到");
                        pointAddRequest.setSourceType(SourceTypeEnum.SIGN);//todo 契约参数
                        entity.setPoints(Long.valueOf(points));
                        entity.setDayNum(new Long((long) signPoints.getDayNum() + 1));
                    } else {
                        pointAddRequest.setMemberId(memberGetByUserIdResponse.getResult().get(0).getId());
                        pointAddRequest.setPoint(5);
                        pointAddRequest.setSourceId(entity.getId());
                        pointAddRequest.setSummary("签到");
                        pointAddRequest.setSourceType(SourceTypeEnum.SIGN);//todo 契约参数
                        entity.setPoints(5L);
                        entity.setDayNum(1L);
                    }
                }
            } else {
                pointAddRequest.setMemberId(memberGetByUserIdResponse.getResult().get(0).getId());
                pointAddRequest.setPoint(5);
                pointAddRequest.setSourceId(entity.getId());
                pointAddRequest.setSummary("签到");
                pointAddRequest.setSourceType(SourceTypeEnum.SIGN);//todo 契约参数
                entity.setPoints(5L);
                entity.setDayNum(1L);
            }
            PointAddResponse pointAddResponse = membershipService.addPoint(pointAddRequest, passport);
            if (pointAddResponse.hasError()) {
                response.addErrors(pointAddResponse.getErrors());
                TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
                return response;
            }
            logger.warn("会员签到积分增加成功");
            if (signPointsMapper.insert(entity, passport) == 0) {
                response.addError(ErrorType.EXPECTATION_NULL, Message.COMMON_CREATE_FAILURE);
                return response;
            }

            response.setId(entity.getId());
            response.setDayNum(entity.getDayNum());
        }else {
            response.addError(ErrorType.BUSINESS_ERROR, "会员不存在");
            return response;
        }
        return response;
    }
    
    /**
     * 更新
     *
     * @param request 更新请求
     * @param passport 用户护照
     * @return 更新应答
     */
    @Override
public SignPointsUpdateResponse update(SignPointsUpdateRequest request, Passport passport) {
        SignPointsUpdateResponse response = new SignPointsUpdateResponse();

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

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



    /**
     * 查询参数表
     *
     * @param request 删除请求
     * @param passport 用户护照
     * @return 删除应答
     */
    @Override
    public ParamSettingFindResponse findParamSetting(ParamSettingFindRequest request, Passport passport){
        ParamSettingFindResponse response = new ParamSettingFindResponse();
        String paramName =  signPointsMapper.findParamSetting(request, passport);
        response.setResult(paramName);
        return response;
    }

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