コード例 #1
0
    public bool    UserAccepted(string FileName)
    {
        string ShortName = CCommon.GetFileName(FileName);

        string[] PreviewLines =
        { "  Начальные строки Файла ..."
          , "___________________________________________________"
          , ""
          , ""
          , ""
          , ""
          , ""
          , ""
          , ""
          , ""
          , ""
          , ""
          , ""
          , "___________________________________________________"
          , " Для загрузки файла нажмите Enter. Для отмены - Esc" };
        if (AFileReader.Open(FileName, CAbc.CHARSET_DOS))
        {
            TotalCredit     = CCommon.CInt64(AFileReader.Head(CSepAFileInfo.H_TOTALCREDIT).Trim());
            PreviewLines[0] = ShortName + " : " + AFileReader.Head(CSepAFileInfo.H_STRCOUNT).Trim()
                              + " строк, общая сумма" + CCommon.StrN(Total_Credit, 11).Replace(",", ".");
            int I = 3;
            while ((AFileReader.Read()) && (I < PreviewLines.Length - 2))
            {
                PreviewLines[I] = CCommon.Left(AFileReader[CSepAFileInfo.L_DEBITMFO].Trim(), 6)
                                  + " : " + CCommon.Left(AFileReader[CSepAFileInfo.L_DEBITACC].Trim(), 14)
                                  + " >>  " + CCommon.Left(AFileReader[CSepAFileInfo.L_CREDITMFO].Trim(), 6)
                                  + " : " + CCommon.Left(AFileReader[CSepAFileInfo.L_CREDITACC].Trim(), 14);
                I++;
            }
        }
        else
        {
            AFileReader.Close();
            return(false);
        }
        AFileReader.Close();
        return(CConsole.GetBoxChoice(PreviewLines));
    }
コード例 #2
0
    public void    PrintConstValues()
    {
        string Answer = "";

        CConsole.Clear();
        CCommon.Print("\tСодержимое шаблона : ");
        for (int CurrentField = 0; CurrentField < TotalFields; CurrentField++)
        {
            if ((Kinds[CurrentField] == -1) &&                                  /*  -1 = постоянное+редактир.  */
                (Values[CurrentField] != null) &&
                (Aliases[CurrentField] != null)
                )
            {
                if ((Values[CurrentField].Trim() != "") &&
                    (Aliases[CurrentField].Trim() != "")
                    )
                {
                    CCommon.Print(CCommon.Left(Infos[CurrentField], 20) + " = " + Values[CurrentField]);
                }
            }
        }
    }
コード例 #3
0
    //-----------------------------------------------------------------------------------------
    //	основная программа
    public static void Main()
    {
        const bool DEBUG       = false;
        const int  MAX_COLUMNS = 299;                                           // максимальное количество столбцов

        int[]       ColWidth = new   int[MAX_COLUMNS];                          // ширины столбцов
        int         ColNumber = 0;
        int         ALineNumber = 0;
        int         AFieldNumber = 0;
        string      AFileName = "";
        string      ModelFileName = CCommon.GetTempDir() + "\\" + "AMaker.mod";
        string      Now_Date_Str = CCommon.DtoC(CCommon.Today()).Substring(2, 6);
        string      Now_Time_Str = CCommon.Hour(CCommon.Now()).ToString("00") + CCommon.Minute(CCommon.Now()).ToString("00");
        CTsvWriter  TsvWriter = new   CTsvWriter();
        CTextReader TextReader = new   CTextReader();
        string      TsvFileName = "$";
        string      InpFileName = "";
        int         InpColCount = 0;
        int         I, SourceMode = -2;                                         // откуда читать данные : 0=ClipBoard , 1=CSV , 2=DIF
        string      Tmps = "";

        string[] SubTmps;
        //----------------------------------------------------------
        CCommon.Print("  Программа для cоздания А-файлов с платежами на основе форматных данных,");
        CCommon.Print("  полученных из электронной таблицы (CVS/DIF). Версия 2.03 от 17.09.2019г.");
        if (DEBUG)
        {
            InpFileName = "F:\\Trash\\Kazna1.csv";
        }
        else
        if (CCommon.ParamCount() < 2)
        {
            CCommon.Print("");
            CCommon.Print(" Формат запуска : ");
            CCommon.Print("      AMaker3    Имя_файла  ");
            CCommon.Print(" где : ");
            CCommon.Print("      Имя_файла  - имя файла данных в формате CSV или DIF ");
            CCommon.Print("");
            return;
        }
        else
        {
            InpFileName = CAbc.ParamStr[1].Trim();
        }

        if (InpFileName == "*")
        {
            SourceMode = 0;
        }
        else
        {
            switch (CCommon.GetExtension(InpFileName).ToUpper())
            {
            case    ".CSV": {
                SourceMode = 1;
                break;
            }

            case    ".DIF": {
                SourceMode = 2;
                break;
            }

            case    ".MOD": {
                SourceMode = -1;
                break;
            }

            default: {
                CCommon.Print("Неправильный тип файла !");
                SourceMode = -2;
                break;
            }
            }
        }
        //----------------------------------------------------------
        // если выбран файл с шаблоном, то выводим его на экран
        if (SourceMode == -1)
        {
            if (AModel.LoadFromFile(InpFileName))
            {
                AModel.PrintConstValues();
                if (CConsole.GetBoxChoice("Использовать теперь этот шаблон ?", " Да = Enter . Нет = Esc ."))
                {
                    if (CCommon.FileExists(ModelFileName))
                    {
                        CCommon.DeleteFile(ModelFileName);
                    }
                    if (CCommon.FileExists(ModelFileName))
                    {
                        CCommon.Print("Ошибка удаления файла " + ModelFileName);
                    }
                    else if (!CCommon.CopyFile(InpFileName, ModelFileName))
                    {
                        CCommon.Print("Ошибка записи файла  " + ModelFileName);
                    }
                    return;
                }
            }
        }
        else
        if (CCommon.FileExists(ModelFileName))
        {
            AModel.LoadFromFile(ModelFileName);
        }
        if ((SourceMode < 0) || (SourceMode > 2))
        {
            CCommon.Print("Неправильная строка параметров !");
            return;
        }
        //----------------------------------------------------------
        // скидываем информацию в промежуточный Tsv-файл
        TsvFileName = CCommon.GetTempName();
        if (TsvFileName == null)
        {
            TsvFileName = InpFileName + ".$$$";
        }
        else if (TsvFileName.Trim() == "")
        {
            TsvFileName = InpFileName + ".$$$";
        }
        if (SourceMode == 0)
        {
            TsvWriter.LoadFromClipboard();
            if (!TsvWriter.SaveToFile(TsvFileName))
            {
                CCommon.Print("Ошибка записи в файл " + TsvFileName);
                return;
            }
        }
        if (SourceMode > 0)
        {
            if (!CCommon.FileExists(InpFileName))
            {
                CCommon.Print("Не найден файл " + InpFileName);
                return;
            }
        }
        if (SourceMode == 1)
        {
            if (TsvWriter.LoadFromCsvFile(InpFileName))
            {
                if (!TsvWriter.SaveToFile(TsvFileName))
                {
                    CCommon.Print("Ошибка записи в файл " + TsvFileName);
                    return;
                }
            }
            else
            {
                CCommon.Print("Ошибка чтения файла " + InpFileName);
                return;
            }
        }
        if (SourceMode == 2)
        {
            if (TsvWriter.LoadFromDifFile(InpFileName))
            {
                if (!TsvWriter.SaveToFile(TsvFileName))
                {
                    CCommon.Print("Ошибка записи в файл " + TsvFileName);
                    return;
                }
            }
            else
            {
                CCommon.Print("Ошибка чтения файла " + InpFileName);
                return;
            }
        }
        //----------------------------------------------------------
        // подсчитываем количество столбцов во входящем файле , а также ширину этих столбцов
        for (I = 0; I < MAX_COLUMNS; I++)
        {
            ColWidth[I] = 0;
        }
        for (I = 0; I < (MAX_LINES * MAX_FILES); I++)
        {
            Cents[I] = 0;
        }
        if (!TextReader.Open(TsvFileName, CAbc.CHARSET_WINDOWS))
        {
            CCommon.Print("Ошибка чтения файла" + TsvFileName);
            TsvFile.Close();
            CCommon.DeleteFile(TsvFileName);
            return;
        }
        if (!TextReader.Read())
        {
            CCommon.Print("Ошибка чтения файла" + TsvFileName);
            TsvFile.Close();
            CCommon.DeleteFile(TsvFileName);
            return;
        }
        for (I = 0; I < 20; I++)
        {
            Tmps    = TextReader.Value;
            SubTmps = Tmps.Split(CCommon.Chr(9));
            if (SubTmps != null)
            {
                if (SubTmps.Length > InpColCount)
                {
                    InpColCount = SubTmps.Length;
                }
                for (ColNumber = 0; ColNumber < SubTmps.Length; ColNumber++)
                {
                    if (SubTmps[ColNumber].Length > ColWidth[ColNumber])
                    {
                        ColWidth[ColNumber] = SubTmps[ColNumber].Length;
                    }
                }
            }
            else
            {
                InpColCount = 0;
            }
            if (!TextReader.Read())
            {
                break;
            }
        }
        TextReader.Close();
        if (InpColCount == 0)
        {
            CCommon.Print("Не получается распознать входные данные ");
            CCommon.DeleteFile(TsvFileName);
            return;
        }
        //----------------------------------------------------------
        // выводим столбцы на экран и запрос пользователю ( помним , что в Csv - файле нумерация столбцов начинается с 1 )
        CConsole.Clear();
        if (!TsvFile.Open(TsvFileName, CAbc.CHARSET_WINDOWS))
        {
            CCommon.Print("Ошибка чтения файла " + TsvFileName);
            return;
        }
        for (I = 0; I < (System.Console.WindowHeight - 1); I++)
        {
            if (!TsvFile.Read())
            {
                break;
            }
            Tmps = "";
            for (ColNumber = 0; ColNumber < InpColCount; ColNumber++)
            {
                Tmps += CCommon.Left(TsvFile[ColNumber + 1], ColWidth[ColNumber]) + "¦";
            }
            if (Tmps.Length > 0)
            {
                if (Tmps.Length < System.Console.WindowWidth - 1)
                {
                    CCommon.Print(Tmps);
                }
                else
                {
                    CCommon.Print(Tmps.Substring(0, System.Console.WindowWidth - 2));
                }
            }
        }
        TsvFile.Close();
        if (!CConsole.GetBoxChoice("Для продолжения обработки нажмите Enter.", "", "Для выхода нажмите Esc. "))
        {
            CCommon.DeleteFile(TsvFileName);
            return;
        }
        CConsole.Clear();
        //----------------------------------------------------------
        // распознавание столбцов во входящем файле ( помним , что в Csv - файле нумерация столбцов начинается с 1 )
        for (ColNumber = 0; ColNumber < InpColCount; ColNumber++)
        {
            CConsole.Clear();
            CCommon.Print("");
            if (!TsvFile.Open(TsvFileName, CAbc.CHARSET_WINDOWS))
            {
                CCommon.Print("Ошибка чтения файла " + TsvFileName);
                TsvFile.Close();
                CCommon.DeleteFile(TsvFileName);
                return;
            }
            for (I = 0; I < (System.Console.WindowHeight - 1); I++)
            {
                if (!TsvFile.Read())
                {
                    break;
                }
                else
                {
                    CCommon.Print(" " + TsvFile[ColNumber + 1]);
                }
            }
            TsvFile.Close();
            if (!AModel.RecognizeColumn(ColNumber + 1))
            {
                CCommon.DeleteFile(TsvFileName);
                return;
            }
        }
        CConsole.Clear();
        //----------------------------------------------------------
        // запрашиваем у пользователя значения постоянных полей
        AModel.AskFixedValues();
        //----------------------------------------------------------
        // подсчитываем количество строк и общую сумму по входному файлу
        TotalLines = 0;
        TotalCents = 0;
        if (!TsvFile.Open(TsvFileName, CAbc.CHARSET_WINDOWS))
        {
            CCommon.Print("Ошибка чтения файла " + TsvFileName);
            TsvFile.Close();
            CCommon.DeleteFile(TsvFileName);
            return;
        }
        while (TsvFile.Read())
        {
            if (IsLineEmpty())
            {
                continue;
            }
            Cents[TotalLines] = CCommon.CLng(GetColValue(CSepAFileInfo.L_SUMA).Trim());
            TotalCents       += Cents[TotalLines];
            TotalLines++;
        }
        TsvFile.Close();
        //-----------------------------------------------------------
        // запрашиваем у пользователя имя файла , в который будет записан результат
        string ShortName = ConstPartOfName;

        CCommon.Write("Краткое имя результирующего файла ( " + ShortName + " ) : ");
        ShortName = CCommon.Input().Trim();
        if (ShortName.Length > 0)
        {
            ConstPartOfName = CCommon.Left(ShortName, 8);
        }
        //-----------------------------------------------------------
        // сверяем с пользователем общее количество строк и общую сумму
        if (!CConsole.GetBoxChoice(" Всего строк : " + CCommon.Right(TotalLines.ToString(), 11)
                                   , " Общая сумма : " + CCommon.StrN(TotalBucks, 11).Replace(",", ".")
                                   , "_________________________________"
                                   , "Для продолжения нажмите Enter."
                                   , "Для выхода - Esc. "
                                   )
            )
        {
            CCommon.DeleteFile(TsvFileName);
            return;
        }
        CConsole.Clear();
        //-----------------------------------------------------------
        // записываем результатов работы программы в файлы
        if (!TsvFile.Open(TsvFileName, CAbc.CHARSET_WINDOWS))
        {
            CCommon.Print("Ошибка чтения файла " + TsvFileName);
            TsvFile.Close();
            CCommon.DeleteFile(TsvFileName);
            return;
        }
        BatchNum = 0;
        //
        while (TotalLines > 0)
        {
            AFileName = GetAFileName();
            if (!AFile.Create(AFileName, CAbc.CHARSET_DOS))
            {
                CCommon.Print("Ошибка создания файла " + AFileName);
                break;
            }
            else
            {
                CCommon.Print(AFileName);
            }
            //
            AFile.Head[CSepAFileInfo.H_EMPTYSTR]      = "";
            AFile.Head[CSepAFileInfo.H_CRLF1]         = CAbc.CRLF;
            AFile.Head[CSepAFileInfo.H_FILENAME]      = CCommon.Left(AFileName, 12);
            AFile.Head[CSepAFileInfo.H_DATE]          = Now_Date_Str;
            AFile.Head[CSepAFileInfo.H_TIME]          = Now_Time_Str;
            AFile.Head[CSepAFileInfo.H_STRCOUNT]      = TotalLinesInBatch().ToString();
            AFile.Head[CSepAFileInfo.H_TOTALDEBET]    = "0";
            AFile.Head[CSepAFileInfo.H_TOTALCREDIT]   = TotalCentsInBatch().ToString();
            AFile.Head[CSepAFileInfo.H_DES]           = "0";
            AFile.Head[CSepAFileInfo.H_DES_ID]        = "UIAB00";
            AFile.Head[CSepAFileInfo.H_DES_OF_HEADER] = "";
            AFile.Head[CSepAFileInfo.H_CRLF2]         = CAbc.CRLF;
            //
            if (!AFile.WriteHeader())
            {
                CCommon.Print("Ошибка записи файла " + AFileName);
                AFile.Close();
                break;
            }
            //
            for (ALineNumber = 0; ALineNumber < TotalLinesInBatch(); ALineNumber++)
            {
                do
                {
                    if (!TsvFile.Read())
                    {
                        break;
                    }
                }while   (IsLineEmpty());
                for (AFieldNumber = 0; AFieldNumber < AModel.TotalFields; AFieldNumber++)
                {
                    AFile.Line[AFieldNumber] = GetColValue(AFieldNumber);
                }
                if (!AFile.WriteLine())
                {
                    CCommon.Print("Ошибка записи файла " + AFileName);
                    break;
                }
                AModel.IncNumber();
            }
            AFile.Close();
            BatchNum++;
            TotalLines -= TotalLinesInBatch();
        }
        TsvFile.Close();
        CCommon.DeleteFile(TsvFileName);
    }
コード例 #4
0
    //  - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    //  Получить имя файла с помощью текстового меню
    public static string   SelectFileName(string FileMask)
    {
        if (FileMask == null)
        {
            return("");
        }
        if (FileMask.Trim().Length == 0)
        {
            return("");
        }
        string[] FileList;
        FileList = CCommon.GetFileList(FileMask);
        if (FileList == null)
        {
            return("");
        }
        if (FileList.Length == 0)
        {
            return("");
        }
        int FileCount = 0;

        foreach (string FileName in FileList)
        {
            if (FileName != null)
            {
                if (FileName.Trim() != "")
                {
                    if (CCommon.GetFileName(FileName).IndexOf("_") < 0)
                    {
                        FileCount++;
                    }
                }
            }
        }
        if (FileCount < 1)
        {
            return("");
        }
        string[] FileNames = new   string[FileCount];
        int      I         = 0;

        foreach (string FileName in FileList)
        {
            if (FileName != null)
            {
                if (FileName.Trim() != "")
                {
                    if ((CCommon.GetFileName(FileName).IndexOf("_") < 0) && (I < FileCount))
                    {
                        FileNames[I++] = FileName;
                    }
                }
            }
        }
        string[] MenuItems = new   string[FileCount];
        for (I = 0; I < FileCount; I++)
        {
            MenuItems[I] = CCommon.GetFileName(FileNames[I]);
            long FileSize = CCommon.GetFileSize(FileNames[I]);
            if (FileSize < 892)
            {
                FileSize = 0;
            }
            else
            {
                FileSize = (FileSize - 298) / 594;
            }
            MenuItems[I] = CCommon.Left(CCommon.GetFileName(FileNames[I]), 16) + " " + CCommon.Right(FileSize.ToString(), 5) + " строк";
        }
        I = CConsole.GetMenuChoice(MenuItems);
        if (I > 0)
        {
            return(FileNames[I - 1]);
        }
        return("");
    }
コード例 #5
0
    public static bool    WriteVFiles(int DayDate, string DestinationFolder, int VMode)
    {
        CSepVWriter A         = new   CSepVWriter();
        string      File_Name = "!"
                                + (VMode == 0 ? "V" : "W")
                                + "UUIA"
                                + CCommon.StrY(CCommon.Month(DayDate), 1)
                                + CCommon.StrY(CCommon.Day(DayDate), 1)
                                + "."
                                + CCommon.Right("0" + CCommon.Hour(CCommon.Clock()), 2)
                                + CCommon.StrY(CCommon.Minute(CCommon.Clock()) >> 1, 1);

        if (!A.Create(DestinationFolder + "\\" + File_Name, CAbc.CHARSET_DOS))
        {
            return(false);
        }

        CRecordSet Data = new CRecordSet(Connection1);

        if (Data.Open("exec  dbo.pMega_OpenGate_Report;3   @TaskCode='ErcGate', @DateFrom = " + DayDate.ToString() + " , @Mode = " + VMode.ToString()))
        {
            if (!Data.Read())
            {
                A.Head[CSepVFileInfo.H_EMPTYSTR]    = "";                                                       // char[100]  // Пеpвые 100 - пpобелы
                A.Head[CSepVFileInfo.H_CRLF1]       = CAbc.CRLF;                                                // char[  2]; // Символ концец строки
                A.Head[CSepVFileInfo.H_FILENAME]    = CCommon.Left(File_Name.Trim(), 12);                       // char[ 12]; // Наименование  файла
                A.Head[CSepVFileInfo.H_DATE]        = Now_Date_Str;                                             // char[  6]; // Дата создания файла
                A.Head[CSepVFileInfo.H_TIME]        = Now_Time_Str;                                             // char[  4]; // Дата создания файла
                A.Head[CSepVFileInfo.H_STRCOUNT]    = "0";                                                      // char[  6]; // Количество ИС в файле
                A.Head[CSepVFileInfo.H_TOTALDEBET]  = "0";                                                      // char[ 16]; // Сумма дебета по файлу
                A.Head[CSepVFileInfo.H_TOTALCREDIT] = "0";                                                      // char[ 16]; // Сумма кpедита по файлу
                A.Head[CSepVFileInfo.H_EMPTYSTR2]   = "";                                                       // char[ 64]; // Пустое пространство
                A.Head[CSepVFileInfo.H_CRLF2]       = CAbc.CRLF;                                                // char[  2]; // Символ конец строки
                if (!A.WriteHeader())
                {
                    Data.Close();
                    A.Close();
                    return(false);
                }
            }
            else
            {
                A.Head[CSepVFileInfo.H_EMPTYSTR]    = "";                                                       // char[100]  // Пеpвые 100 - пpобелы
                A.Head[CSepVFileInfo.H_CRLF1]       = CAbc.CRLF;                                                // char[  2]; // Символ концец строки
                A.Head[CSepVFileInfo.H_FILENAME]    = CCommon.Left(File_Name.Trim(), 12);                       // char[ 12]; // Наименование  файла
                A.Head[CSepVFileInfo.H_DATE]        = Now_Date_Str;                                             // char[  6]; // Дата создания файла
                A.Head[CSepVFileInfo.H_TIME]        = Now_Time_Str;                                             // char[  4]; // Дата создания файла
                A.Head[CSepVFileInfo.H_STRCOUNT]    = Data["TotalLines"].Trim();                                // char[  6]; // Количество ИС в файле
                A.Head[CSepVFileInfo.H_TOTALDEBET]  = "0";                                                      // char[ 16]; // Сумма дебета по файлу
                A.Head[CSepVFileInfo.H_TOTALCREDIT] = Data["TotalCents"].Trim();                                // char[ 16]; // Сумма кpедита по файлу
                A.Head[CSepVFileInfo.H_EMPTYSTR2]   = "";                                                       // char[ 64]; // Пустое пространство
                A.Head[CSepVFileInfo.H_CRLF2]       = CAbc.CRLF;                                                // char[  2]; // Символ конец строки
                if (!A.WriteHeader())
                {
                    Data.Close();
                    A.Close();
                    return(false);
                }
                do
                {
                    A.Line[CSepVFileInfo.L_DEBITMFO]  = Data["SourceCode"].Trim();                                              // char[  9]; // Дебет-МФО
                    A.Line[CSepVFileInfo.L_DEBITACC]  = Data["DebitMoniker"].Trim();                                            // char[ 14]; // Дебет-счет
                    A.Line[CSepVFileInfo.L_CREDITMFO] = Data["TargetCode"].Trim();                                              // char[  9]; // Кредит-МФО
                    A.Line[CSepVFileInfo.L_CREDITACC] = Data["CreditMoniker"].Trim();                                           // char[ 14]; // Кредит счет
                    A.Line[CSepVFileInfo.L_FLAG]      = "1";                                                                    // char[  1]; // Флаг `дебет/кредит`
                    A.Line[CSepVFileInfo.L_SUMA]      = Data["CrncyCents"].Trim();                                              // char[ 16]; // Сумма в копейках
                    A.Line[CSepVFileInfo.L_DTYPE]     = Data["Kind"].Trim();                                                    // char[  2]; // Вид документа
                    A.Line[CSepVFileInfo.L_NDOC]      = Data["DocNum"].Trim();                                                  // char[ 10]; // Номер документа
                    A.Line[CSepVFileInfo.L_CURRENCY]  = Data["CurrencyId"].Trim();                                              // char[  3]; // Валюта
                    A.Line[CSepVFileInfo.L_DATE1]     = CCommon.DtoC(CCommon.CInt32(Data["DayDate"].Trim())).Substring(2, 6);   // char[  6]; // Дата платежа
                    A.Line[CSepVFileInfo.L_ID]        = Data["Id"].Trim();                                                      // char[  9]; // Идентификатор документа
                    A.Line[CSepVFileInfo.L_FILENAME1] = Data["FileName"].Trim();                                                // char[ 12]; // Имя файла N 1
                    A.Line[CSepVFileInfo.L_LINENUM1]  = Data["LineNum"].Trim();                                                 // char[  6]; // Номер строки в файле N 1
                    A.Line[CSepVFileInfo.L_FILENAME2] = Data["FileName"].Trim();                                                // char[ 12]; // Имя файла N 2
                    A.Line[CSepVFileInfo.L_LINENUM2]  = Data["LineNum"].Trim();                                                 // char[  6]; // Номер строки в файле N 2
                    A.Line[CSepVFileInfo.L_STATUS]    = (((CCommon.CInt32(Data["ProcessFlag"].Trim()) & 3) == 3)  ? "Y" : "N"); // char[  1]; // Флаг квитовки платежа
                    A.Line[CSepVFileInfo.L_TIME]      = Now_Time_Str;                                                           // char[  4]; // Время
                    A.Line[CSepVFileInfo.L_NOL1]      = "0";                                                                    // char[  1]; //
                    A.Line[CSepVFileInfo.L_NOL2]      = "0";                                                                    // char[  1]; //
                    A.Line[CSepVFileInfo.L_CRLF]      = CAbc.CRLF;                                                              // char[  2]; // Символы конца строки
                    if (!A.WriteLine())
                    {
                        Data.Close();
                        A.Close();
                        return(false);
                    }
                }       while   (Data.Read());
            }
        }
        Data.Close();
        A.Close();
        return(true);
    }
コード例 #6
0
ファイル: Day.cs プロジェクト: shkumat/mgb_day
    // - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    //	Вычитка списка пунктов открытия/закрытия дня
    static bool    LoadHistory(int Mode)
    {
        int MenuItemWidth = (Mode == 1) ? 32 : 25;

        Connection = new CConnection(ConnectionString);
        RecordSet  = new   CRecordSet(Connection);
        bool Result = false;

        if (RecordSet.Open("exec Mega_Day_Close;10  @DayDate=" + DayDate.ToString() + " , @Mode= " + Mode.ToString()))
        {
            while (RecordSet.Read())
            {
                if (CCommon.CInt(RecordSet["Cnt"]) == 0)
                {
                    MNames.Add(CCommon.Left(RecordSet["Name"], MenuItemWidth) + "*");
                }
                else
                {
                    MNames.Add(CCommon.Left(RecordSet["Name"], MenuItemWidth) + "* " + RecordSet["Cnt"].Trim());
                }
                MCommands.Add(RecordSet["Command"]);
                MParams.Add(RecordSet["Params"]);
                MKinds.Add(RecordSet["Kind"]);
                Result = true;
            }
        }
        else
        {
            Result = false;
        }
        RecordSet.Close();
        int MenuCount = MNames.Count;

        MenuNames    = new   string[MenuCount];
        MenuKinds    = new   string[MenuCount];
        MenuParams   = new   string[MenuCount];
        MenuCommands = new   string[MenuCount];
        MenuCount    = 0;
        foreach (string MenuName in MNames)
        {
            MenuNames[MenuCount++] = MenuName;
        }
        MenuCount = 0;
        foreach (string MenuKind in MKinds)
        {
            MenuKinds[MenuCount++] = MenuKind;
        }
        MenuCount = 0;
        foreach (string MenuParam in MParams)
        {
            MenuParams[MenuCount++] = MenuParam;
        }
        MenuCount = 0;
        foreach (string MenuCommand in MCommands)
        {
            MenuCommands[MenuCount++] = MenuCommand;
        }
        MCommands.Clear();
        MParams.Clear();
        MKinds.Clear();
        MNames.Clear();
        Connection.Close();
        return(Result);
    }