public Response <TrackLog> Put(TrackLog entity)
 {
     if (entity == null)
     {
         return(ResponseHelper <TrackLog> .ErrorResponse(new System.Exception("Entity is Empty or Null"), entity));
     }
     return(contract.Update(entity));
 }
Exemple #2
0
 public void WriteTrackLog(string msg)
 {
     if (TrackLog == null)
     {
         return;
     }
     TrackLog.AppendFormat("{0:hh:MM:ss}{1}", DateTime.Now, msg);
     TrackLog.AppendLine();
 }
Exemple #3
0
        internal bool AddTrackLog(TrackLog log)
        {
            string str = "INSERT INTO `track_log`(`track_id`, `type`, `dev_id`, `stock_count`, `log_time`, `memo`, `area`) " +
                         "VALUES('{0}', '{1}', '{2}', '{3}', {4}, '{5}', '{6}')";
            string sql = string.Format(@str, log.track_id, log.type, log.dev_id, log.stock_count,
                                       GetTimeOrNull(log.log_time), log.memo, log.area);
            int row = mSql.ExcuteSql(sql);

            return(row >= 1);
        }
 public Task Consume(ConsumeContext <TrackLogCreatedEvent> context)
 {
     return(Task.Run(() =>
     {
         if (context.Message != null)
         {
             var repository = MongoRepository <TrackLog> .Instance;
             TrackLog trackLog = MapperProvider.MapTo <TrackLog>(context.Message);
             trackLog.CreateTime = trackLog.CreateTime.AddHours(8);   // UTC时间转换
             trackLog.RequestTime = trackLog.RequestTime.AddHours(8); // UTC时间转换
             var obj = repository.Add(trackLog);
         }
         Console.WriteLine($"Recevied By TrackLogCreatedEventConsumer:{context.Message.GUID}");
     }));
 }
Exemple #5
0
        public ushort AddTrackLog(ushort area, uint devid, uint trackid, TrackLogE logtype, string memo = "")
        {
            ushort   storecount = PubMaster.Goods.GetTrackStockCount(trackid);
            TrackLog log        = new TrackLog()
            {
                dev_id      = devid,
                track_id    = trackid,
                type        = (byte)logtype,
                stock_count = storecount,
                log_time    = DateTime.Now,
                memo        = memo,
                area        = area
            };

            PubMaster.Mod.TraSql.AddTrackLog(log);
            return(storecount);
        }
Exemple #6
0
    public void LogEntry(Command comm, string currentTarget, Vector3 playerPos, string type, string details)
    {
        TrackLog log = new TrackLog();

        log.target    = currentTarget;
        log.command   = comm;
        log.type      = type;
        log.details   = details;
        log.xypos     = playerPos;
        log.timestamp = TimeManager.Instance.MasterSource.TotalTime;

        float delta      = 0.0f;
        int   trackCount = trackLogs.Count;

        if (trackCount > 0)
        {
            delta = log.timestamp - trackLogs[trackCount - 1].timestamp;
        }

        log.deltatime = delta;

        trackLogs.Add(log);
    }
        public Response <string> ProcessTest(Microsoft.AspNetCore.Http.IFormFile file, string identification)
        {
            Response <string> responseProcessTest = new Response <string>();

            responseProcessTest.IsSuccess = false;
            Response <string> responseUpload = uploadServices.Load(file);

            TrackLog trackLog = new TrackLog {
                FileName = responseUpload.Result, Identification = identification
            };

            trackLog.TrackLogDetails = new List <TrackLogDetail>();


            if (responseUpload.IsSuccess)
            {
                Response <bool> resultValidate = this.validateFileService.Validate(responseUpload.Result);
                if (resultValidate.IsSuccess)
                {
                    Response <WorkingDays> response = this.readService.Read(responseUpload.Result);
                    if (response.IsSuccess)
                    {
                        Response <List <ProcessInformationResponse> > responseExecute = processInformation.Execute(response.Result);
                        if (responseExecute.IsSuccess)
                        {
                            Response <string> responseGenerateFile = exportFileService.GenerateFile(responseExecute.Result);

                            if (responseGenerateFile.IsSuccess)
                            {
                                responseProcessTest.Result    = responseGenerateFile.Result;
                                responseProcessTest.IsSuccess = true;
                                trackLog.IsValid = true;
                            }
                            else
                            {
                                responseProcessTest.Message = new List <MessageResult> {
                                    new MessageResult {
                                        Message = "Ocurrió un error al Generar la información."
                                    }
                                };
                                trackLog.TrackLogDetails.Add(new TrackLogDetail {
                                    Message = responseGenerateFile.Message.FirstOrDefault().ToString()
                                });
                            }
                        }
                        else
                        {
                            responseProcessTest.Message = new List <MessageResult> {
                                new MessageResult {
                                    Message = "Ocurrió un error al Procesar la información."
                                }
                            };
                            trackLog.TrackLogDetails.Add(new TrackLogDetail {
                                Message = responseExecute.Message.FirstOrDefault().ToString()
                            });
                        }
                    }
                    else
                    {
                        responseProcessTest.Message = new List <MessageResult> {
                            new MessageResult {
                                Message = "Ocurrió un error al Leer la información."
                            }
                        };
                        trackLog.TrackLogDetails.Add(new TrackLogDetail {
                            Message = response.Message.FirstOrDefault().ToString(),
                        });
                    }
                }
                else
                {
                    responseProcessTest.Message = new List <MessageResult> {
                        new MessageResult {
                            Message = "Ocurrió un error al Validar la información."
                        }
                    };
                    trackLog.TrackLogDetails.Add(new TrackLogDetail {
                        Message = resultValidate.Message.FirstOrDefault().Message.ToString(),
                    });
                }
            }
            Response <TrackLog> responesTrack = this.trackLogService.Post(trackLog);

            return(responseProcessTest);
        }