Example #1
0
        private async Task ExecuteGenerateSourcesCommand()
        {
            IsBusy      = true;
            tokenSource = new CancellationTokenSource();
            token       = tokenSource.Token;

            var sources = new SourceGenerator(Categories);

            ConsoleWrite("Выгрузка листа блоков данных...");

            var resultFile = Path.Combine(RootDirectory, "sources.xlsx");
            await Task.Run(() =>
            {
                ExcelDataWriter.WriteExcelFromArray(resultFile, sources.PrintDBlistToArray(), "DB_list", token);
            }, token).ConfigureAwait(false);

            Progress = 40;
            ConsoleWrite("Старт генерации source-файлов...");
            await sources.SetPeripheryFields(token);

            await sources.PrintAllSourcesToFiles(RootDirectory, token);

            Progress = 90;
            ConsoleWrite("Генерация source-файлов завершена");

            Categories.ReplaceRange(sources.Categories);

            Progress = 0;
            IsBusy   = false;
            ConsoleWrite("Выполнено! Генерация завершена, основная структура сигналов обновлена");
        }
Example #2
0
        protected virtual TSheetBuilder DataContentInternal <T>(IEnumerable <T> data, IExcelReportConfiguration configuration)
            where T : class
        {
            var writer = new ExcelDataWriter(Worksheet, StyleApplier, Cursor, InitColumnNumber);

            writer.Write(data, configuration);
            return((TSheetBuilder)this);
        }
Example #3
0
        public ISheetBuilder Block(Action <IBlockBuilder> action)
        {
            Cursor.CurrentColumn = InitColumnNumber;
            var initRowNumber = Cursor.CurrentRow;

            var block = new BlockBuilder.BlockBuilder(Worksheet);

            action(block);
            var writer = new ExcelDataWriter(Worksheet, StyleApplier, Cursor, InitColumnNumber);

            block.Write(writer);
            Cursor.CurrentRow    = initRowNumber + block.GetRowCount();
            Cursor.CurrentColumn = InitColumnNumber;
            return(this);
        }
Example #4
0
        private async Task ExecuteCategorizeTableCommand()
        {
            IsBusy      = true;
            tokenSource = new CancellationTokenSource();
            token       = tokenSource.Token;

            ConsoleWrite("Запуск цикла сортировки таблицы по категориям...");


            int count = Categories.Count;

            if (count == 0)
            {
                ConsoleWrite("Не заданы категории для обработки таблицы сигналов!..", LogTag.Error);
                return;
            }

            await Task.Run(() =>
            {
                ProgressLabel = "Выгрузка категорий";
                int i         = 1;

                foreach (var cat in Categories)
                {
                    var list = cat.Keys.Select(k => k.Name).ToList();
                    cat.AddCollection(SymbolTable.ExtractListByKeys(list));

                    Progress = (int)((double)Categories.Count / 100 * i++);
                    lock (SyncLock)
                    {
                        ConsoleWrite($"Осталось категорий: {count--}");
                    }
                }

                ProgressLabel = "Уточнение типов";
                i             = 1;

                foreach (var cat in Categories)
                {
                    if (cat.Id == 10000)
                    {
                        var sysN = 0;
                        var devN = 0;

                        foreach (var pid in cat.S7Items)
                        {
                            sysN           = int.Parse(pid.SystemNumber);
                            devN           = int.Parse(pid.DeviceNumber);
                            var n          = (int)cat.Id++;
                            pid.DbFullName = "DB" + n;
                        }
                    }

                    if (cat.Id != 99)
                    {
                        continue;
                    }
                    foreach (var sc in cat.S7Items)
                    {
                        sc.DbFullName = "DB99";
                    }
                    Progress = (int)((double)Categories.Count / 100 * i++);
                }

                lock (SyncLock)
                {
                    ConsoleWrite("Выполнена сортировка таблицы по ключам и категориям");
                }

                var resultFile = Path.Combine(RootDirectory, "result.xlsx");
                bool isOk      = ExcelDataWriter.WriteExcel(resultFile, Categories);

                var message = isOk ? "Выполнена выгрузка категорий в Excel" : "Ошибка записи файла";
                lock (SyncLock)
                {
                    ConsoleWrite(message);
                }

                resultFile = Path.Combine(RootDirectory, "result_unsorted.xlsx");
                isOk       = ExcelDataWriter.WriteExcelFromArray(resultFile, SymbolTable.GetSymbolsArray(), "unsorted", token);
            }, token).ConfigureAwait(false);

            ProgressLabel = "Выполнено";
            Progress      = 0;
            ConsoleWrite("Выполнено! Таблица  сигналов отсортирована и обработана");
            IsBusy = false;
        }
Example #5
0
        private async Task ExecuteSerializeTableCommand()
        {
            if (!File.Exists(FilePath))
            {
                ConsoleWrite("Ошибка открытия файла", LogTag.Error);
                return;
            }

            IsBusy        = true;
            ProgressLabel = "Выполняется...";

            tokenSource = new CancellationTokenSource();
            token       = tokenSource.Token;

            await Task.Run(() =>
            {
                var dt = OneService.GenerateTableFromExcel(FilePath);
                if (dt == null)
                {
                    lock (SyncLock)
                    {
                        ConsoleWrite("Ошибка открытия файла", LogTag.Error);
                        return;
                    }
                }
                Progress = 30;

                IList <SymbolTableItemModel> items = dt.AsEnumerable()
                                                     .Select(row =>
                                                             new SymbolTableItemModel
                {
                    SignalName     = row.Field <string>("SignalName"),
                    SignalAdress   = row.Field <string>("SignalAdress"),
                    SignalDataType = row.Field <string>("SignalDataType"),
                    SignalComment  = row.Field <string>("SignalComment")
                })
                                                     .ToList();

                SymbolTable = new SymbolTableModel(items);

                lock (SyncLock) { ConsoleWrite("Таблица прочитана"); }
                if (token.IsCancellationRequested)
                {
                    lock (SyncLock) { ConsoleWrite("Операция отменена"); }
                    return;
                }

                SymbolTable.AnalyseAndSetTags();
                SymbolTable.SortTable();

                lock (SyncLock) { ConsoleWrite("Анализ таблицы выполнен"); }
                Progress = 50;

                ExcelDataWriter.BackupFile(FilePath);

                var fi   = new FileInfo(FilePath);
                var dest = Path.Combine(RootDirectory, "result_" + fi.Name);

                bool isOk = ExcelDataWriter.WriteExcelFromArray(dest, SymbolTable.GetSymbolsArray(), "SymbolTable", token);
                Progress  = 100;
                var s     = isOk ? "Адаптированная таблица сохранена" : "Ошибка записи файла";
                lock (SyncLock) { ConsoleWrite(s); }
            }, token).ConfigureAwait(false);

            IsBusy        = false;
            ProgressLabel = "Завершено";
        }