Example #1
0
            public KeszRec(MozgRec mozgRec, StreamWriter naplo)
            {
                this.RSZ = mozgRec.RSZ;
                this.CSZ = mozgRec.CSZ;
                this.BAR = mozgRec.BAR;

                Eredeti = false;

                WriteNaplo(naplo);
            }
Example #2
0
        static DateTime targetDate;                                                    // A halmozás céldátuma

        static void Main(string[] args)
        {
            Console.WriteLine("******************************************************************************");
            Console.WriteLine("***  Szolgáló  ||  Készletérték kalkuláció adott dátumra  ||  (c) eMeL Bt. ***");
            Console.WriteLine("******************************************************************************");
            Console.WriteLine();

            string paramPath = null;
            string paramDate = null;

            if (args.Length > 0)
            {
                Console.WriteLine("Program paraméterek:");

                foreach (string arg in args)
                {
                    if ((arg.ToUpper() == "/HELP") || (arg.ToUpper() == "/H") ||
                        (arg.ToUpper() == "-HELP") || (arg.ToUpper() == "-H") ||
                        (arg.ToUpper() == "--HELP") || (arg.ToUpper() == "--H") ||
                        (arg == "/?") || (arg == "-?") || (arg == "--?"))
                    {
                        Console.WriteLine("A program használata:");
                        Console.WriteLine();
                        Console.WriteLine("KESZ_Kalkulator.exe [alkönyvtárnév] [cél dátum]");
                        Console.WriteLine();
                        Console.WriteLine("Az alkönyvtárba kell elhelyezni a KESZ.dbf MOZG.dbf CIKK.dbf és RAKT.dbf állományokat,");
                        Console.WriteLine("és ebben a könyvtárban keletkeznek az eredmény XLS állományok.");
                        Console.WriteLine("Ha nem határozzuk meg, akkor a .\\ (aktuális) alkönyvtárat használja a program.");
                        Console.WriteLine("Ha nem határozunk meg cél dátumot, akkor az bekérésre kerül.");
                        Console.WriteLine("A dátum formátuma: ÉÉÉÉ.HH.NN");
                        Console.WriteLine();
                        Console.WriteLine("Részletesebb információk a www.emel.hu/programok/help/kesz_kalkulator webcímen.");
                        Console.ReadLine();
                        return;
                    }

                    //

                    string info = "?????  Nem értelmezhető paraméter!";

                    Uri      uri = new Uri(arg, UriKind.RelativeOrAbsolute);
                    DateTime tempDate;

                    if ((paramPath == null) && Directory.Exists(arg))
                    {
                        paramPath = arg;
                        info      = "létező könyvtárnév";
                    }
                    else if ((paramPath == null) && uri.IsWellFormedOriginalString())
                    {
                        paramPath = arg;
                        info      = "megfelelő könyvtárnév";
                    }
                    else if ((paramDate == null) && DateTime.TryParse(arg, out tempDate))
                    {
                        paramDate = arg;
                        info      = "cél dátum";
                    }

                    Console.WriteLine("paraméter: '{0}': {1}", arg, info);
                }

                Console.WriteLine();
            }

            //---------------------------------------------------

            if (String.IsNullOrWhiteSpace(paramPath))
            {
                paramPath = @".\";
            }

            if (!Directory.Exists(paramPath))
            {
                Console.WriteLine("A '{0}' alkönyvtár nem létezik!", paramPath);
            }

            string filenameKESZ = Path.Combine(paramPath, "KESZ.DBF");
            string filenameMOZG = Path.Combine(paramPath, "MOZG.DBF");
            string filenameCIKK = Path.Combine(paramPath, "CIKK.DBF");
            string filenameRAKT = Path.Combine(paramPath, "RAKT.DBF");

            if (!File.Exists(filenameKESZ))
            {
                Console.WriteLine("A '{0}' adatállomány nem létezik!", filenameKESZ);
            }

            if (!File.Exists(filenameMOZG))
            {
                Console.WriteLine("A '{0}' adatállomány nem létezik!", filenameMOZG);
            }

            if (!File.Exists(filenameCIKK))
            {
                Console.WriteLine("A '{0}' adatállomány nem létezik!", filenameCIKK);
            }

            if (!File.Exists(filenameRAKT))
            {
                Console.WriteLine("A '{0}' adatállomány nem létezik!", filenameRAKT);
            }

            //---------------------------------------------------

            if (!DateTime.TryParse(paramDate, out targetDate))
            {
                Console.WriteLine("A megadott cél dátum [{0}] érvénytelen!", paramDate);
                Console.WriteLine("Jelenleg a dátumot kötelező parancssorban megadni, még nincs bekérés megvalósítva.");
                return;
            }

            string filenameRESULT = Path.Combine(paramPath, "KESZ.Kalkulalt_" + targetDate.ToString("yyyyMMdd") + ".XLS");     // Eredmény állomány

            //---------------------------------------------------

            List <KeszRec> keszRecs = new List <KeszRec>();

            using (var keszTable = Table.Open(filenameKESZ))
            {
                Console.WriteLine("KESZ tábla beolvasása...     [{0} rekord]", keszTable.recCount);

                Reader keszReader = keszTable.OpenReader(Encoding.GetEncoding(852));

                while (keszReader.Read())
                {
                    string rsz = keszReader.GetString("RSZ");
                    string csz = keszReader.GetString("CSZ");

                    decimal?temp;

                    temp = keszReader.GetDecimal("BAR");
                    decimal bar = (temp == null) ? (decimal)0.0 : (decimal)temp;

                    temp = keszReader.GetDecimal("NMEN");
                    decimal nmen = (temp == null) ? (decimal)0.0 : (decimal)temp;


                    KeszRec keszRec = (from kr in keszRecs
                                       where (kr.RSZ == rsz) && (kr.CSZ == csz) && (kr.BAR == bar)
                                       select kr).FirstOrDefault();

                    if (keszRec == null)
                    {
                        keszRec = new KeszRec(keszReader);

                        keszRecs.Add(keszRec);
                    }
                    else
                    {
                        keszRec.ZMEN += nmen;
                    }
                }
            }

            //---------------------------------------------------

            using (StreamWriter mozgStreamWriter = new StreamWriter(Path.Combine(paramPath, "__KESZ_Kalkulator.MOZG.naplo.txt")),
                   keszStreamWriter = new StreamWriter(Path.Combine(paramPath, "__KESZ_Kalkulator.KESZ.naplo.txt")))
            {
                using (var mozgTable = Table.Open(filenameMOZG))
                {
                    Reader mozgReader = mozgTable.OpenReader(Encoding.GetEncoding(852));

                    Console.WriteLine("MOZG tábla feldolgozása...   [{0} rekord]", mozgTable.recCount);

                    int     datumonTul    = 0;
                    decimal kimaradtErtek = 0;

                    while (mozgReader.Read())
                    {
                        MozgRec mozgRec = new MozgRec(mozgReader);

                        if (!mozgRec.ZART)
                        {
                            bool hasznalni = (mozgRec.BDAT <= targetDate);

                            mozgRec.WriteNaplo(mozgStreamWriter, hasznalni);

                            if (hasznalni)
                            {
                                KeszRec foundRec = (from keszRec in keszRecs
                                                    where (keszRec.RSZ == mozgRec.RSZ) &&
                                                    (keszRec.CSZ == mozgRec.CSZ) &&
                                                    (keszRec.BAR == mozgRec.BAR)
                                                    select keszRec).FirstOrDefault();

                                if (foundRec == null)
                                {
                                    foundRec = new KeszRec(mozgRec, keszStreamWriter);
                                    keszRecs.Add(foundRec);
                                }
                                else
                                {
                                    foundRec.ZMEN += (mozgRec.MMEN * mozgRec.SIGN);
                                }
                            }
                            else
                            {
                                datumonTul++;
                                kimaradtErtek += (mozgRec.MMEN * mozgRec.SIGN * mozgRec.BAR);
                            }
                        }
                    }

                    Console.WriteLine("   Dátumon túli tétel: {0} db", datumonTul);
                    Console.WriteLine("   Dátumon túli érték: {0:0.00} Ft", kimaradtErtek);
                }
            }

            keszRecs.Sort();

            //---------------------------------------------------

            using (var cikkTable = Table.Open(filenameCIKK))
            {
                Reader cikkReader = cikkTable.OpenReader(Encoding.GetEncoding(852));

                Console.WriteLine("CIKK tábla feldolgozása...   [{0} rekord]", cikkTable.recCount);

                while (cikkReader.Read())
                {
                    string csz = cikkReader.GetString("CSZ");

                    var foundRecs = from keszRec in keszRecs
                                    where (keszRec.CSZ == csz)
                                    select keszRec;

                    if (foundRecs != null)
                    {
                        string cmn = cikkReader.GetString("CMN");
                        string cme = cikkReader.GetString("CME");

                        foreach (var keszRec in foundRecs)
                        {
                            keszRec.CMN = cmn;
                            keszRec.CME = cme;
                        }
                    }
                }
            }

            //---------------------------------------------------

            List <RaktSum> raktSums =
                (from keszRec in keszRecs
                 group keszRec by keszRec.RSZ into rakt
                 orderby rakt.Key
                 select new RaktSum()
            {
                RSZ = rakt.Key, ZMEN = rakt.Sum(r => r.ZMEN), ZERT = rakt.Sum(r => r.ZMEN * r.BAR)
            }).ToList();

            raktSums.Sort();

            //---------------------------------------------------

            using (var raktTable = Table.Open(filenameRAKT))
            {
                Reader raktReader = raktTable.OpenReader(Encoding.GetEncoding(852));

                Console.WriteLine("RAKT tábla feldolgozása...   [{0} rekord]", raktTable.recCount);

                while (raktReader.Read())
                {
                    string rsz = raktReader.GetString("RSZ");

                    RaktSum foundRakt = (from raktRec in raktSums
                                         where (raktRec.RSZ == rsz)
                                         select raktRec).FirstOrDefault();

                    if (foundRakt != null)
                    {
                        foundRakt.RMN = raktReader.GetString("RMN");
                    }
                }
            }

            //---------------------------------------------------

            Console.WriteLine();
            Console.WriteLine("Eredmény kiiratása Excel állományba...");

            SaveToExcel(filenameRESULT, keszRecs, raktSums);

            //---------------------------------------------------

            Console.WriteLine();
            Console.WriteLine("Program befejezése: <Enter> billentyű leütése.");
            Console.ReadLine();
        }