Exemple #1
0
 public void Add(DatasList DatasList, Data Data, DataChecker DataChecker)
 {
     if (DataChecker.DataCheck(Data))
     {
         DatasList.Add(Data);
     }
 }
        public static void CreateTraceFile(DatasList dataList, string traceFileNamePath, string logFileName, string traceFileName)
        {
            int filesCount = dataList.Data.Count() / 100;

            if (dataList.Data.Count() % 100 > 0)
            {
                filesCount++;
            }

            FileTraceModel model = new FileTraceModel()
            {
                FileName = logFileName, FileItemsList = new List <FileItemModel>(), FilesItemCount = filesCount
            };

            for (int i = 0; i < filesCount; i++)
            {
                StringBuilder itemName = new StringBuilder(logFileName);
                FileItemModel fileItem = new FileItemModel()
                {
                    FileItemName = itemName.Replace(".log", "-000" + (i + 1)).Append(".log").ToString(), FileState = FileStatus.Empty
                };
                model.FileItemsList.Add(fileItem);
            }

            model.TotalCount = dataList.Data.Count();
            FileHelper.WriteTextFile(traceFileNamePath, string.Empty, false);
            FileHelper.WriteTextFile(traceFileNamePath, JsonConvert.SerializeObject(model), false);
        }
        private void CreateUpdateTraceFile(DatasList dataList, string fileName)
        {
            string directoryPath    = Path.Combine(Directory.GetCurrentDirectory(), DirectoryConfig.DirectoryName);
            string dataTypeFileName = dataList.Data.FirstOrDefault()?.Type;

            string traceFileName = "Trace";

            traceFileName = TraceHelper.TraceNameCreator(fileName, dataTypeFileName, directoryPath);

            string directoryTracePath = Path.Combine(directoryPath, dataTypeFileName + "-Trace");
            string traceFileNamePath  = Path.Combine(directoryTracePath, traceFileName);

            if (!Directory.Exists(directoryTracePath))
            {
                DirectoryInfo di = Directory.CreateDirectory(directoryTracePath);
            }
            if (!System.IO.File.Exists(traceFileNamePath))
            {
                TraceHelper.CreateTraceFile(dataList, traceFileNamePath, fileName, traceFileName);
            }
            else
            {
                TraceHelper.UpdateTraceFile(dataList, traceFileNamePath, fileName, traceFileName);
            }
        }
Exemple #4
0
 public Value GetValue(DatasList DatasList, Key Key, DataChecker DataChecker)
 {
     if (DataChecker.KeyCheck(Key))
     {
         return(DatasList.GetValue(Key));
     }
     return(new NullValue());
 }
Exemple #5
0
 public bool Reduce(DatasList DatasList, Key Key, Value Value, DataChecker DataChecker)
 {
     if (DataChecker.KeyCheck(Key))
     {
         return(DatasList.Reduce(Key, Value));
     }
     return(false);
 }
Exemple #6
0
        public ActionResult <object> DataLogger([FromBody] DatasList request)
        {
            request.TotalCount = request.Data.Count();

            _loggerService.CreateFilesByDataType(request);


            return(Ok(request));
        }
Exemple #7
0
        private DatasList ReadTraceData(string fileItemNamePath)
        {
            string    fileString = "";
            DatasList data       = new DatasList {
                Data = new List <Data>()
            };

            if (System.IO.File.Exists(fileItemNamePath))
            {
                fileString = System.IO.File.ReadAllText(fileItemNamePath);
                data       = JsonConvert.DeserializeObject <DatasList>(fileString);
            }

            return(data);
        }
        public void CreateFilesByDataType(DatasList request)
        {
            foreach (var typedList in request.Data.GroupBy(x => x.Type))
            {
                DatasList dataList = new DatasList {
                    Data = new List <Data>()
                };
                dataList.Data.AddRange(typedList);
                dataList.TotalCount = dataList.Data.Count();

                string date     = $"{DateTime.Now.Year}-{DateTime.Now.Month}-{DateTime.Now.Day}";
                string fileName = $"{typedList.Key}-{date}.log";

                string path = Path.Combine(Directory.GetCurrentDirectory(), DirectoryConfig.DirectoryName);

                if (!Directory.Exists(path))
                {
                    DirectoryInfo di = Directory.CreateDirectory(path);
                }
                string    newPath = Path.Combine(path, fileName);
                string    list    = "";
                DatasList data    = null;

                if (System.IO.File.Exists(newPath))
                {
                    list = System.IO.File.ReadAllText(newPath);
                    data = JsonConvert.DeserializeObject <DatasList>(list);
                }

                if (data != null)
                {
                    dataList.Data.AddRange(data.Data);
                    dataList.TotalCount = dataList.Data.Count();
                    System.IO.File.WriteAllText(newPath, string.Empty);
                }
                DatasList traceListData = new DatasList()
                {
                    Data = new List <Data>()
                };
                traceListData.Data.AddRange(typedList);
                CreateUpdateTraceFile(dataList, fileName);
                FileHelper.WriteTextFile(newPath, JsonConvert.SerializeObject(dataList), false);
            }
        }
        public static void UpdateTraceFile(DatasList dataList, string traceFileNamePath, string fileName, string traceFileName)
        {
            FileTraceModel model = ReadTraceFile(traceFileNamePath);
            //model.Data.AddRange(dataList.Data);

            int filesCount = 0;
            int itemsCount = dataList.Data.Count();

            while (itemsCount >= 100)
            {
                filesCount++;
                itemsCount -= 100;
            }
            if (itemsCount % 100 > 0 || itemsCount > 0)
            {
                filesCount++;
            }



            for (int i = model.FilesItemCount + 1; i <= filesCount; i++)
            {
                StringBuilder itemName   = new StringBuilder(fileName);
                int           nameNumber = model.FilesItemCount + 1;
                FileItemModel fileItem   = new FileItemModel()
                {
                    FileItemName = itemName.Replace(".log", "-000" + (nameNumber)).Append(".log").ToString(), FileState = FileStatus.Empty
                };
                model.FileItemsList.Add(fileItem);
                model.FilesItemCount = filesCount;
            }

            model.TotalCount = dataList.Data.Count();
            FileHelper.WriteTextFile(traceFileNamePath, string.Empty, false);
            FileHelper.WriteTextFile(traceFileNamePath, JsonConvert.SerializeObject(model), false);
        }
Exemple #10
0
        public void CreateOrUpdateLoggerTraceInDirectory()
        {
            string        directoryPath = Path.Combine(Directory.GetCurrentDirectory(), DirectoryConfig.DirectoryName);
            DirectoryInfo rootDi        = new DirectoryInfo(directoryPath);

            foreach (FileInfo file in rootDi.GetFiles())
            {
                DatasList      data      = null;
                FileTraceModel traceData = null;
                string         filePath  = Path.Combine(directoryPath, file.Name);
                DatasList      dataList  = new DatasList {
                    Data = new List <Data>()
                };
                ReadLogDataFile(filePath, out data);
                if (data != null)
                {
                    dataList.Data.AddRange(data.Data);
                    dataList.TotalCount = dataList.Data.Count();
                    string dataTypeFileName = dataList.Data.FirstOrDefault()?.Type;
                    string traceFileName    = TraceHelper.TraceNameCreator(file.Name, dataTypeFileName, directoryPath);

                    string directoryTracePath = Path.Combine(directoryPath, dataTypeFileName + "-Trace");
                    string traceFileNamePath  = Path.Combine(directoryTracePath, traceFileName);

                    string traceString = "";
                    if (System.IO.File.Exists(traceFileNamePath))
                    {
                        traceString = System.IO.File.ReadAllText(traceFileNamePath);
                        traceData   = JsonConvert.DeserializeObject <FileTraceModel>(traceString);
                    }
                    else
                    {
                        TraceHelper.CreateTraceFile(dataList, traceFileNamePath, file.Name, traceFileName);
                    }

                    if (traceData != null)
                    {
                        foreach (var item in traceData.FileItemsList)
                        {
                            if (item.FileState == FileStatus.Full)
                            {
                                continue;
                            }
                            string    fileItemNamePath = Path.Combine(directoryTracePath, item.FileItemName);
                            DatasList organizedList    = new DatasList()
                            {
                                Data = new List <Data>()
                            };
                            var toBeFetchedData = data.Data.Where(x => x.IsProcessed == false).Take(100).ToList();
                            organizedList.Data.AddRange(toBeFetchedData);
                            organizedList.TotalCount = toBeFetchedData.Count();
                            organizedList.Data.ForEach(UpdateProcessedItems);
                            if (item.FileState == FileStatus.Empty)
                            {
                                if (organizedList.Data.Any())
                                {
                                    FileHelper.WriteTextFile(fileItemNamePath, JsonConvert.SerializeObject(organizedList), false);
                                }
                            }

                            if (item.FileState == FileStatus.HavingSize)
                            {
                                DatasList traceFileData = ReadTraceData(fileItemNamePath);
                                if (organizedList.Data.Any())
                                {
                                    organizedList.Data.AddRange(traceFileData.Data);
                                    organizedList.TotalCount = organizedList.Data.Count();
                                    FileHelper.WriteTextFile(fileItemNamePath, JsonConvert.SerializeObject(organizedList), false);
                                }
                            }
                            if (organizedList.Data.Count == 100)
                            {
                                item.FileState = FileStatus.Full;
                            }
                            if (organizedList.Data.Count < 100)
                            {
                                item.FileState = FileStatus.HavingSize;
                            }

                            traceData.TotalCount = data.Data.Count();
                            //FileHelper.WriteTextFile(traceFileNamePath, string.Empty, false);
                            FileHelper.WriteTextFile(traceFileNamePath, JsonConvert.SerializeObject(traceData), false);

                            foreach (var addeditem in organizedList.Data)
                            {
                                Data first = null;
                                foreach (var data1 in data.Data)
                                {
                                    if (addeditem != null && data1 == addeditem)
                                    {
                                        first = data1;
                                        break;
                                    }
                                }

                                if (first != null)
                                {
                                    first.IsProcessed = true;
                                }
                            }

                            var x = data.Data.Where(data1 => data1.IsProcessed == true).ToList();
                            //data.Data.ForEach(UpdateProcessedItems);
                            data.TotalCount     = data.Data.Count();
                            data.ProcessedCount = data.Data.Count(data1 => data1.IsProcessed == true);
                            //FileHelper.WriteTextFile(filePath, string.Empty, false);
                            FileHelper.WriteTextFile(filePath, JsonConvert.SerializeObject(data), false);
                        }
                    }
                }
            }
        }
Exemple #11
0
 public InventoryCounter()
 {
     inventoryList = new InventoryList();
     DataChecker   = new InvenrtoryDataChecker();
 }
Exemple #12
0
 // public void Load(DatasList DatasList,List<List<Data>> Dataslist){
 //     DatasList.Load(Dataslist);
 // // }
 public PublicDatasList GetDatasList(DatasList DatasList)
 {
     return(DatasList.GetDatasList());
 }
Exemple #13
0
 public ItemLibrary()
 {
     itemLibrary = new ItemDatasList();
     DataChecker = new ItemLibraryChecker();
 }