Example #1
0
        public static void Execute()
        {
            Task.Factory.StartNew(() =>
            {
                ILogger m_ilogger         = new Logger.Logger();
                ISerializer m_serializer  = new JsonSerializer(m_ilogger);
                RabbitMQPeeker m_rabbitMQ = new RabbitMQPeeker(m_ilogger, m_serializer);
                IDatabase db;

                //队列
                string queue = "";
                //路由key
                string routingKey = "";

                m_rabbitMQ.PeekMessageByRabbitMQ(queue, routingKey, (string content) =>
                {
                    //转换成Fujica缴费实体
                    IssuedRecord payModel = m_serializer.Deserialize <IssuedRecord>(content);
                    if (payModel != null)
                    {
                        //验证当前是否临时车
                        if (payModel.CardType == 3)
                        {
                            //验证当前车牌是否在场
                            string carNumber = payModel.CarNo;
                            int dbIndex      = GetDatabaseNumber(carNumber);
                            db = FollowRedisHelper.GetDatabase(dbIndex);
                            //去redis中查询车辆是否在场,返回在场实体
                            VehicleEntryDetailModel entryModel = m_serializer.Deserialize <VehicleEntryDetailModel>(db.HashGet(carNumber, payModel.ParkingCode));
                            //不为空,则代表车辆在场
                            if (entryModel != null)
                            {
                                //fujica缴费实体传过来的“停车记录编号”和本系统中的“当次停车唯一标识”的值相等,确认是同一条记录
                                if (payModel.OffLineOrderId == entryModel.RecordGuid)
                                {
                                    //查询当前车辆的计费模板,以获取缴费超时时间,计算最后出场时间
                                    db = FollowRedisHelper.GetDatabase(0);
                                    BillingTemplateModel billingModel = m_serializer.Deserialize <BillingTemplateModel>(db.HashGet("BillingTemplateList", entryModel.CarTypeGuid));
                                    int timeOut = TemplateDataTimeOut(billingModel, m_ilogger, m_serializer);

                                    //发送缴费数据到相机
                                    SendPayData.Execute(entryModel.ParkingCode, entryModel.RecordGuid, entryModel.CarNo, entryModel.BeginTime, payModel.FeeEndTime.AddMinutes(timeOut));
                                }
                            }
                        }
                    }

                    return(RabbitMQAction.ACCEPT);
                });
            });
        }
Example #2
0
        public static ResponseCommon DataHandle(ILogger m_ilogger, ISerializer m_serializer)
        {
            ResponseCommon response = new ResponseCommon()
            {
                IsSuccess = false,
                MsgType   = MsgType.PayCard
            };

            IDatabase db;

            db = RedisHelper.GetDatabase(4);
            string redisContent = db.ListLeftPop(mq_ListKey);

            if (string.IsNullOrEmpty(redisContent))
            {
                response.MessageContent = "redis数据库读取值为空";
                return(response);
            }
            response.RedisContent = redisContent;
            m_ilogger.LogInfo(LoggerLogicEnum.Tools, "", "", "", "Fujica.com.cn.MonitorServiceClient.PayDataManager", "支付数据接收成功.原始数据:" + redisContent);

            IssuedRecord recordModel = m_serializer.Deserialize <IssuedRecord>(redisContent);

            if (recordModel == null)
            {
                response.MessageContent = "redis数据库读取值转换成实体失败:";
                return(response);
            }
            if (string.IsNullOrEmpty(recordModel.ParkingCode) ||
                string.IsNullOrEmpty(recordModel.CarNo) ||
                recordModel.CardType <= 0 ||
                string.IsNullOrEmpty(recordModel.TradeNo)
                //|| string.IsNullOrEmpty(inmodel.Remark)
                )
            {
                response.MessageContent = "redis数据转换成实体后必要参数缺失";
                return(response);
            }
            if (recordModel.CardType == 1)
            {
                if (recordModel.RenewDay <= 0 && recordModel.RenewDayType <= 0)
                {
                    response.MessageContent = "redis数据转换成实体后必要参数缺失";
                    return(response);
                }
            }
            else if (recordModel.CardType == 2 && recordModel.Price <= 0)
            {
                response.MessageContent = "redis数据转换成实体后必要参数缺失";
                return(response);
            }

            db = RedisHelper.GetDatabase(0);
            //判断当前订单号,是否已执行过
            string mqPayDataListKey = "PayDataList:" + recordModel.ParkingCode + ":" + DateTime.Now.ToString("yyyyMMdd");

            if (db.HashExists(mqPayDataListKey, recordModel.TradeNo))
            {
                response.MessageContent = "当前订单记录重复执行";
                m_ilogger.LogInfo(LoggerLogicEnum.Tools, recordModel.TradeNo, recordModel.ParkingCode, recordModel.CardNo, "Fujica.com.cn.MonitorServiceClient.PayDataManager", $"TradeNo:{recordModel.TradeNo} 当前订单记录重复执行");
                return(response);
            }
            else
            {
                db.HashSet(mqPayDataListKey, recordModel.TradeNo, redisContent);
                db.KeyExpire(mqPayDataListKey, DateTime.Now.AddDays(1).Date);
            }

            string           hashkey   = recordModel.ParkingCode + Convert.ToBase64String(Encoding.UTF8.GetBytes(recordModel.CarNo));
            CardServiceModel cardModel = m_serializer.Deserialize <CardServiceModel>(db.HashGet("PermanentCarList", hashkey));

            if (cardModel == null)
            {
                cardModel = GetCard(hashkey, m_ilogger, m_serializer);
                if (cardModel == null)
                {
                    response.MessageContent = "根据车场编号和车牌号,读取卡务模型为空";
                    m_ilogger.LogError(LoggerLogicEnum.Tools, recordModel.TradeNo, recordModel.ParkingCode, recordModel.CardNo, "Fujica.com.cn.MonitorServiceClient.PayDataManager", "根据车场编号和车牌号,读取卡务模型为空");
                    return(response);
                }
            }

            CarTypeModel cartypemodel = m_serializer.Deserialize <CarTypeModel>(db.HashGet("CarTypeList", cardModel.CarTypeGuid));

            if (cartypemodel == null)
            {
                response.MessageContent = "根据车类Guid,读取车类模型为空";
                m_ilogger.LogError(LoggerLogicEnum.Tools, recordModel.TradeNo, recordModel.ParkingCode, recordModel.CardNo, "Fujica.com.cn.MonitorServiceClient.PayDataManager", "根据车类Guid,读取车类模型为空");
                return(response);
            }

            try
            {
                if (recordModel.CardType == 1)
                {
                    //月卡延期(截止时间、延期金额、支付方式)
                    //暂时只控制截至日期,暂无日志记录,所以不需要存储延期金额和支付方式
                    cardModel.EndDate = FormatEndDate(cardModel.EndDate, recordModel.RenewDay, recordModel.RenewDayType);

                    bool flag = false;
                    //修改数据库
                    flag = SaveMonthCarToDB(cardModel, m_ilogger, m_serializer);
                    if (!flag)
                    {
                        response.MessageContent = "月卡保存数据库失败";
                        m_ilogger.LogError(LoggerLogicEnum.Tools, recordModel.TradeNo, recordModel.ParkingCode, recordModel.CardNo, "Fujica.com.cn.MonitorServiceClient.PayDataManager", "月卡保存数据库失败");
                        return(response);
                    }
                    //修改redis
                    flag = SaveMonthCarToRedis(cardModel, m_ilogger, m_serializer);
                    if (!flag)
                    {
                        response.MessageContent = "月卡保存数据库成功,保存redis失败";
                        m_ilogger.LogError(LoggerLogicEnum.Tools, recordModel.TradeNo, recordModel.ParkingCode, recordModel.CardNo, "Fujica.com.cn.MonitorServiceClient.PayDataManager", "月卡保存数据库成功,保存redis失败");
                        return(response);
                    }
                    //发送给相机
                    SendMonthCarToCameras(cardModel, m_ilogger, m_serializer);
                    //发送给Fujica
                    flag = SendMonthCarToFujica(cardModel, cartypemodel.Idx);
                    if (!flag)
                    {
                        response.MessageContent = "月卡保存数据库、redis成功,发送Fujica失败";
                        m_ilogger.LogError(LoggerLogicEnum.Tools, recordModel.TradeNo, recordModel.ParkingCode, recordModel.CardNo, "Fujica.com.cn.MonitorServiceClient.PayDataManager", "月卡保存数据库、redis成功,发送Fujica失败");
                        return(response);
                    }
                    m_ilogger.LogInfo(LoggerLogicEnum.Tools, recordModel.TradeNo, recordModel.ParkingCode, recordModel.CardNo, "Fujica.com.cn.MonitorServiceClient.PayDataManager", "月卡保存数据库、redis、发送Fujica成功");
                }
                else if (recordModel.CardType == 2)
                {
                    //储值卡充值(充值金额、充值方式)
                    //暂时只控制余额,暂无日志记录,所以不需要操作充值金额和充值方式
                    cardModel.Balance += recordModel.Price;

                    bool flag = false;
                    //修改数据库、redis
                    flag = SaveValueCarToDB(cardModel, m_ilogger, m_serializer);
                    if (!flag)
                    {
                        response.MessageContent = "储值卡保存数据库失败";
                        m_ilogger.LogError(LoggerLogicEnum.Tools, recordModel.TradeNo, recordModel.ParkingCode, recordModel.CardNo, "Fujica.com.cn.MonitorServiceClient.PayDataManager", "储值卡保存数据库失败");
                        return(response);
                    }

                    //修改redis
                    flag = SaveValueCarToRedis(cardModel, m_ilogger, m_serializer);
                    if (!flag)
                    {
                        response.MessageContent = "储值卡保存数据库成功,保存redis失败";
                        m_ilogger.LogError(LoggerLogicEnum.Tools, recordModel.TradeNo, recordModel.ParkingCode, recordModel.CardNo, "Fujica.com.cn.MonitorServiceClient.PayDataManager", "储值卡保存数据库成功,保存redis失败");
                        return(response);
                    }
                    //发送给相机
                    SendValueCarToCameras(cardModel, m_ilogger, m_serializer);
                    //发送给Fujica
                    flag = SendValueCarToFujica(cardModel, cartypemodel.Idx);
                    if (!flag)
                    {
                        response.MessageContent = "储值卡保存数据库、redis成功,发送Fujica失败";
                        m_ilogger.LogError(LoggerLogicEnum.Tools, recordModel.TradeNo, recordModel.ParkingCode, recordModel.CardNo, "Fujica.com.cn.MonitorServiceClient.PayDataManager", "储值卡保存数据库、redis成功,发送Fujica失败");
                        return(response);
                    }
                    m_ilogger.LogInfo(LoggerLogicEnum.Tools, recordModel.TradeNo, recordModel.ParkingCode, recordModel.CardNo, "Fujica.com.cn.MonitorServiceClient.PayDataManager", "储值卡保存数据库、redis、发送Fujica成功");
                }

                response.IsSuccess      = true;
                response.MessageContent = "支付数据操作成功";
            }
            catch (Exception ex)
            {
                m_ilogger.LogFatal(LoggerLogicEnum.Tools, recordModel.TradeNo, cardModel.ParkCode, recordModel.CardNo, "Fujica.com.cn.MonitorServiceClient.PayDataManager", cardModel.CarNo + "支付数据发生异常", ex.ToString());

                response.MessageContent = cardModel.CarNo + "支付数据发生异常:" + ex.ToString();
                return(response);
            }

            return(response);
        }