예제 #1
0
    public bool    LoadFromFile(string FileName)
    {
        CTextReader TextReader = new   CTextReader();
        string      Tmps       = "";

        string[] SubTmps;
        if (FileName == null)
        {
            return(false);
        }
        if (FileName.Trim() == "")
        {
            return(false);
        }
        if (!TextReader.Open(FileName, CAbc.CHARSET_WINDOWS))
        {
            return(false);
        }
        while (TextReader.Read())
        {
            Tmps = TextReader.Value.Trim();
            if (Tmps == null)
            {
                continue;
            }
            if (Tmps == "")
            {
                continue;
            }
            if (Tmps.Substring(0, 1) == ";")
            {
                continue;
            }
            if (Tmps.IndexOf("=") < 1)
            {
                continue;
            }
            SubTmps = Tmps.Split(CCommon.Chr(61));
            if (SubTmps.Length < 2)
            {
                continue;
            }
            Tmps = SubTmps[0].Trim().ToUpper();
            for (int CurrentField = 0; CurrentField < TotalFields; CurrentField++)
            {
                if ((Aliases[CurrentField].Trim().ToUpper() == Tmps
                     ) &&
                    ((CurrentField == CSepAFileInfo.L_PURPOSE) ||
                     (SubTmps[1].IndexOf("/") < 0)
                    )
                    )
                {
                    Values[CurrentField] = SubTmps[1].Trim();
                }
            }
        }
        TextReader.Close();
        return(true);
    }
예제 #2
0
 bool IFileOfColumnsWriter.Create(string FileName, int CharSet, params int[] MetaData)
 {
     if (MetaData != null)
     {
         if (MetaData.Length > 0)
         {
             Delimiter = CCommon.Chr(MetaData[0]).ToString();
         }
     }
     return(base.Create(FileName, CharSet));
 }
예제 #3
0
        static void DrawBox()
        {
            int    I;
            string ONE_SPACE = " ";

            BorderKind = BorderKind & 3;
            System.Console.CursorLeft = Left - 3;
            System.Console.CursorTop  = Top - 2;
            System.Console.Write(CCommon.Space(Width + 6));

            System.Console.CursorLeft = Left - 3;
            System.Console.CursorTop  = Top - 1;
            System.Console.Write(ONE_SPACE);
            System.Console.Write(CCommon.Chr(BORDER_SYMBOLS[BorderKind * 8 + 4]));
            System.Console.Write(CCommon.Replicate(CCommon.Chr(BORDER_SYMBOLS[BorderKind * 8]).ToString(), (Width + 2)));
            System.Console.Write(CCommon.Chr(BORDER_SYMBOLS[BorderKind * 8 + 5]));
            System.Console.Write(ONE_SPACE);

            string EMPTY_SPACE = CCommon.Space(Width + 2);

            for (I = 0; I <= Height - 1; I++)
            {
                System.Console.CursorLeft = Left - 3;
                System.Console.CursorTop  = Top + I;
                System.Console.Write(ONE_SPACE);
                System.Console.Write(CCommon.Chr(BORDER_SYMBOLS[BorderKind * 8 + 2]));
                System.Console.Write(EMPTY_SPACE);
                System.Console.Write(CCommon.Chr(BORDER_SYMBOLS[BorderKind * 8 + 2]) + " ");
            }

            System.Console.CursorLeft = Left - 3;
            System.Console.CursorTop  = Top + Height;
            System.Console.Write(ONE_SPACE);
            System.Console.Write(CCommon.Chr(BORDER_SYMBOLS[BorderKind * 8 + 6]));
            System.Console.Write(CCommon.Replicate(CCommon.Chr(BORDER_SYMBOLS[BorderKind * 8]).ToString(), Width + 2));
            System.Console.Write(CCommon.Chr(BORDER_SYMBOLS[BorderKind * 8 + 7]));
            System.Console.Write(ONE_SPACE);

            System.Console.CursorLeft = Left - 3;
            System.Console.CursorTop  = Top + Height + 1;
            System.Console.Write(CCommon.Space(Width + 6));
        }
예제 #4
0
 bool IFileOfColumnsReader.Open(string FileName, int CharSet, params int[] MetaData)
 {
     TotalLines  = 0;
     TotalFields = 0;
     if (MetaData != null)
     {
         if (MetaData.Length > 0)
         {
             Delimiter = CCommon.Chr(MetaData[0]).ToString();
         }
         else
         {
             Delimiter = null;
         }
     }
     else
     {
         Delimiter = null;
     }
     if (!base.Open(FileName, CharSet))
     {
         return(false);
     }
     while (base.Read())
     {
         TotalLines++;
         AnalyzeIt();
     }
     base.Close();
     if (!base.Open(FileName, CharSet))
     {
         return(false);
     }
     if ((TotalFields == 0) || (TotalLines == 0))
     {
         return(false);
     }
     Sizes   = new   int[TotalFields];
     Offsets = new   int[TotalFields];
     return(true);
 }
예제 #5
0
    //------------------------------------------------------
    //	преобразование Cvs-строки ( разделитель - ; ( точка с запятой ) ) - в Tsv-строку
    string  CommaToTab(string InpStr)
    {
        if (InpStr == null)
        {
            return("");
        }
        else if (InpStr.Trim() == "")
        {
            return("");
        }
        if (InpStr.IndexOf(";") < 0)
        {
            return(InpStr);
        }
        string Comma       = ";";
        char   Quote       = CCommon.Chr(34);
        string DoubleQuote = Quote.ToString() + Quote.ToString();
        string Result      = InpStr.Replace(DoubleQuote, CAbc.FORM_FEED);

        string[] Results = Result.Split(Quote);
        if (Results.Length > 1)
        {
            int I = 0;
            for (I = 0; I < Results.Length; I++)
            {
                if ((I % 2) != 0)
                {
                    Results[I] = Results[I].Replace(Comma, CAbc.CARRIAGE_RETURN);
                }
            }
            Result = System.String.Join("", Results);
        }
        Result = Result.Replace(Comma, CAbc.TAB);
        Result = Result.Replace(CAbc.CARRIAGE_RETURN, Comma);
        Result = Result.Replace(CAbc.FORM_FEED, "'" /*Quote.ToString()*/);
        return(Result);
    }
예제 #6
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);
    }
예제 #7
0
    //-----------------------------------------------------------
    //	запись Tsv-текста в файл
    public bool    SaveToFile(string FileName)
    {
        int    I;
        bool   ContainsEmpty;
        string CurLine;

        string[] Columns;
        if (FileName == null)
        {
            return(false);
        }
        if ((Tsv == null) || (Tsv.Length == 0))
        {
            return(false);
        }
        string[] Lines = Tsv.ToString().Split(CCommon.Chr(13));
        if (Lines == null)
        {
            return(false);
        }
        if (Lines.Length == 0)
        {
            return(false);
        }
        bool        Result     = false;
        CTextWriter TextWriter = new   CTextWriter();

        if (!TextWriter.Create(FileName, CAbc.CHARSET_WINDOWS))
        {
            return(false);
        }

        for (I = 0; I < Lines.Length; I++)
        {
            Result  = true;
            CurLine = Lines[I].Replace(CAbc.BIG_UKR_I, "I").Replace(CAbc.SMALL_UKR_I, "i").Trim();
            if (CurLine.Trim().Length == 0)
            {
                continue;
            }
            ContainsEmpty = true;
            Columns       = CurLine.Split(CCommon.Chr(9));
            if (Columns == null)
            {
                ContainsEmpty = true;                                           // есть пустые ячейки ?
            }
            else if (Columns.Length < 2)
            {
                ContainsEmpty = true;
            }
            else
            {
                foreach (string Item in Columns)
                {
                    if (Item.Trim().Length != 0)
                    {
                        ContainsEmpty = false;
                    }
                }
            }
            if (!ContainsEmpty)
            {
                if (!TextWriter.Add(CurLine + CAbc.CRLF))
                {
                    Result = false;
                }
            }
        }
        TextWriter.Close();
        return(Result);
    }
예제 #8
0
    //-----------------------------------------------------------
    //	чтение данных из  DIF-файла
    public bool    LoadFromDifFile(string InpFileName)
    {
        int    CharSet        = CAbc.CHARSET_WINDOWS;
        string Quote          = CCommon.Chr(34).ToString();
        string Value          = "";
        bool   WaitForAValue  = false;
        bool   HasDataStarted = false;

        Tsv.Length = 0;
        if (InpFileName == null)
        {
            return(false);
        }
        else if (InpFileName.Trim() == "")
        {
            return(false);
        }
        if (IsDosEncoding(InpFileName))
        {
            CharSet = CAbc.CHARSET_DOS;
        }
        if (TextReader.Open(InpFileName, CharSet))
        {
            while (TextReader.Read())
            {
                Value = TextReader.Value.Trim();
                if (Value.Length < 3)
                {
                    continue;
                }
                if (CCommon.Upper(Value) == "EOD")
                {
                    break;
                }
                if (CCommon.Upper(Value) == "BOT")
                {
                    if (HasDataStarted)
                    {
                        Tsv.Append(CAbc.CRLF);
                    }
                    else
                    {
                        HasDataStarted = true;
                    }
                }
                if (!HasDataStarted)
                {
                    continue;
                }
                if (Value.Substring(0, 2) == "0,")
                {
                    Tsv.Append(Value.Substring(2).Replace(",", ".") + CAbc.TAB);
                }
                if (Value.Substring(0, 2) == "1,")
                {
                    WaitForAValue = true;
                }
                if (WaitForAValue == true)
                {
                    if (Value.Substring(0, 1) == Quote)
                    {
                        Tsv.Append(Value.Substring(1, Value.Length - 2).Replace(Quote + Quote, Quote) + CAbc.TAB);
                    }
                    WaitForAValue = true;
                }
            }
        }
        else
        {
            return(false);
        }
        TextReader.Close();
        return(true);
    }