示例#1
0
        /// <summary>
        /// Excel fájlba exportálja a paraméterként megadott terméklistát WHosting szerinti összeállításban a munkamappába, vagy a paraméterként megadott mappába.
        /// Az exportált fájl neve a beállításokban megadott fájlnévből és az aktuális dátumból képződik (YYYYMMDD).
        /// A metódus kérdezés nélkül felülírja a létező listát.
        /// </summary>
        /// <param name="_termekek">A terméklista amelyet exportálni kívánunk.</param>
        /// <param name="_elteromappa">Itt lehetséges megadni az eltérő mappát, ha nem a munkamappába kívánjuk exportálni a terméklistát.</param>
        /// <returns></returns>
        public static async Task FajlbaExportal_WHosting(IList <Model.Termek> _termekek, CancellationToken _canceltoken, string _elteromappa = null)
        {
            if (_termekek == null)
            {
                throw new ArgumentNullException(nameof(_termekek));
            }
            if (_canceltoken == null)
            {
                throw new ArgumentNullException(nameof(_canceltoken));
            }

            FolyamatValtozott?.Invoke(0, 0, string.Format("{0}/{1} termék exportálva ({2:P2})", 0, 0, 0));

            XLWorkbook wb = new XLWorkbook();

            IXLWorksheet wstermek = wb.AddWorksheet("All product");
            int          ctr      = 1;

#if CSAKNOTEBOOK
            int osszestermekszam = Globalisok.Munkaasztal.TermekLista.Count(t => t.ElsoKategoriaID.Equals("M001") && !t.MasodikKategoriaID.Equals("N001"));
#else
            int osszestermekszam = Globalisok.Munkaasztal.TermekLista.Count;
#endif


            // Fejlécek formázása
            (string szoveg, int szelesseg)[] fejlecleiro = new (string szoveg, int szelesseg)[]
示例#2
0
        /// <summary>
        /// Letölti a megadott fájlt az FTP szerverről.
        /// </summary>
        /// <param name="_ftpfajl">A fájl teljes elérési útja az FTP szerveren.</param>
        /// <param name="_lokalisfajl">A letöltött fájl tejles elérési útja.</param>
        /// <param name="_felhasznalo">Felhasználónév az FTP authentikációhoz.</param>
        /// <param name="_jelszo">Jelszó az FTP authentikációhoz.</param>
        /// <returns></returns>
        public static async Task Letolt(string _ftpfajl, string _lokalisfajl, string _felhasznalo = "anonymous", string _jelszo = "")
        {
            WebClient client = new WebClient {
                Credentials = new NetworkCredential(_felhasznalo, _jelszo)
            };

            //client.DownloadFileCompleted += (s, e) => FolyamatValtozott?.Invoke(1L, 1L, "Letöltés kész (100%)");
            client.DownloadProgressChanged += (s, e) =>
                                              FolyamatValtozott?.Invoke(e.BytesReceived, e.TotalBytesToReceive, string.Format("{0} kB/{1} kB letöltve ({2:P2})", e.BytesReceived / 1024L, e.TotalBytesToReceive / 1024L, (double)e.BytesReceived / (double)e.TotalBytesToReceive));

            await client.DownloadFileTaskAsync(_ftpfajl, _lokalisfajl);
        }
示例#3
0
        /// <summary>
        /// Feltölti a megadott fájlt az FTP szerverre.
        /// </summary>
        /// <param name="_lokalisfajl">A feltöltendő fájl tejles elérési útja.</param>
        /// <param name="_ftpfajl">A fájl teljes elérési útja az FTP szerveren.</param>
        /// <param name="_felhasznalo">Felhasználónév az FTP authentikációhoz.</param>
        /// <param name="_jelszo">Jelszó az FTP authentikációhoz.</param>
        /// <returns></returns>
        public static async Task <byte[]> Feltolt(string _lokalisfajl, string _ftpfajl, string _felhasznalo = "anonymous", string _jelszo = "")
        {
            long lfm = new FileInfo(_lokalisfajl).Length;

            WebClient client = new WebClient {
                Credentials = new NetworkCredential(_felhasznalo, _jelszo)
            };

            //client.UploadFileCompleted += (s, e) => FolyamatValtozott?.Invoke(1L, 1L, "Feltöltés kész (100%)");
            client.UploadProgressChanged += (s, e) =>
                                            FolyamatValtozott?.Invoke(e.BytesSent, /*e.TotalBytesToSend*/ lfm, string.Format("{0} kB/{1} kB feltöltve ({2:P2})", e.BytesSent / 1024L, /*e.TotalBytesToSend*/ lfm / 1024L, (double)e.BytesSent / (double)/*e.TotalBytesToSend*/ lfm));

            return(await client.UploadFileTaskAsync(_ftpfajl, WebRequestMethods.Ftp.UploadFile, _lokalisfajl));
        }
示例#4
0
        /// <summary>
        /// Letölti az aktuális terméklistát a HRP szerveréről.
        /// A termékek a munkaasztal HRP listájába kerülnek.
        /// </summary>
        /// <param name="_termekszamlekeresenkent">Mennyi terméket kérjen le egyszerre egy POST requestben.</param>
        /// <param name="_endofsaleseldob">Már nem forgalmazott termékeket eldob?</param>
        /// <param name="_canceltoken"></param>
        /// <returns></returns>
        public static async Task Letolt(int _termekszamlekeresenkent, bool _endofsaleseldob, CancellationToken _canceltoken)
        {
            if (_canceltoken == null)
            {
                throw new ArgumentNullException(nameof(_canceltoken));
            }

            FolyamatValtozott?.Invoke(0, 0, string.Format("{0}/{1} termék lekérve ({2:P2})", 0, 0, 0));

            Globalisok.Munkaasztal.FrissTermekLista = new ObservableCollection <Model.Termek>();

            int oldalszam = 1, elemszam, lekertelemszam = 0;

            do
            {
                if (_canceltoken.IsCancellationRequested)
                {
                    break;
                }

                // Request XML létrehozása
                XmlDocument xml = HRP.Szolgaltatas.MetodusXML(Szolgaltatas.Metodusok.Termeklista);

                // Authentikációs kód megadása
                (xml.SelectSingleNode("/Envelope/Body/Request/Base/AuthCode") as XmlElement).InnerText = Globalisok.Beallitasok.HRPAuthKod;

                // Lekérdezésenkénti termékszám megadása
                (xml.SelectSingleNode("/Envelope/Body/Request/ItemsOnPage") as XmlElement).InnerText = _termekszamlekeresenkent.ToString("D");

                // Oldalszám megadása
                (xml.SelectSingleNode("/Envelope/Body/Request/CurrentPageIndex") as XmlElement).InnerText = oldalszam.ToString("D");

                // Request XML sztringgé alakítása
                string request_xml;

                using (var stringWriter = new StringWriter())
                    using (var xmlTextWriter = XmlWriter.Create(stringWriter, new XmlWriterSettings()
                    {
                        Indent = true
                    }))
                    {
                        xml.WriteTo(xmlTextWriter);
                        xmlTextWriter.Flush();
                        request_xml = stringWriter.GetStringBuilder().ToString();
                    }

                // POST request küldése és a válasz sztring kinyerése
                string rv_xml = await POST.Keres(Globalisok.Beallitasok.HRPURL + HRP.Szolgaltatas.MetodusNev(Szolgaltatas.Metodusok.Termeklista), request_xml);

                // Válasz XML létrehozása
                XmlDocument res_xml = new XmlDocument();

                res_xml.LoadXml(rv_xml);

                // Eredmény kiolvasása a válasz XML-ből
                XmlElement kod       = res_xml.SelectSingleNode("/Envelope/Body/Response/Header/Control/ReturnCode") as XmlElement,
                           uzenet    = res_xml.SelectSingleNode("/Envelope/Body/Response/Header/Control/ReturnText") as XmlElement,
                           listcount = res_xml.SelectSingleNode("/Envelope/Body/Response/Body/ListCount") as XmlElement;

                elemszam = Convert.ToInt32(listcount.InnerText);

                if (elemszam == 0)
                {
                    break;
                }

                // Terméklista kiolvasása a válasz XML-ből
                List <Model.Termek> termeklista = new List <Model.Termek>(_termekszamlekeresenkent);
                XmlNodeList         termeknodes = res_xml.SelectNodes("Envelope/Body/Response/Body/Items/CatalogueItem") as XmlNodeList;

                foreach (XmlNode node in termeknodes)
                {
                    Model.Termek termek = new Model.Termek()
                    {
                        ID                          = (node["ProductId"] as XmlElement).InnerText,
                        Cikkszam                    = (node["PartNumber"] as XmlElement).InnerText,
                        Megnevezes                  = (node["Name"] as XmlElement).InnerText,
                        Leiras                      = (node["Description"] as XmlElement).InnerText,
                        GyartoID                    = ((node["Manufacturer"] as XmlNode)["ManufacturerId"] as XmlElement).InnerText,
                        GyartoMegnevezes            = ((node["Manufacturer"] as XmlNode)["ManufacturerName"] as XmlElement).InnerText,
                        ElsoKategoriaID             = ((node["FirstLevelCategory"] as XmlNode)["FirstLevelCategoryId"] as XmlElement).InnerText,
                        ElsoKategoriaMegnevezes     = ((node["FirstLevelCategory"] as XmlNode)["FirstLevelCategoryName"] as XmlElement).InnerText,
                        MasodikKategoriaID          = ((node["SecondLevelCategory"] as XmlNode)["SecondLevelCategoryId"] as XmlElement).InnerText,
                        MasodikKategoriaMegnevezes  = ((node["SecondLevelCategory"] as XmlNode)["SecondLevelCategoryName"] as XmlElement).InnerText,
                        HarmadikKategoriaID         = ((node["ThirdLevelCategory"] as XmlNode)["ThirdLevelCategoryId"] as XmlElement).InnerText,
                        HarmadikKategoriaMegnevezes = ((node["ThirdLevelCategory"] as XmlNode)["ThirdLevelCategoryName"] as XmlElement).InnerText,
                        GaranciaMod                 = ((node["Garanty"] as XmlNode)["GarantyMode"] as XmlElement).InnerText,
                        GaranciaIdo                 = ((node["Garanty"] as XmlNode)["GarantyTime"] as XmlElement).InnerText,
                        Uj                          = Convert.ToBoolean((node["New"] as XmlElement).InnerText),
                        Kedvezmeny                  = Convert.ToBoolean((node["Discount"] as XmlElement).InnerText),
                        KeszletInfo                 = ((node["Stock"] as XmlNode)["StockInfo"] as XmlElement).InnerText,
                        VanRaktaron                 = Convert.ToBoolean(((node["Stock"] as XmlNode)["HasStock"] as XmlElement).InnerText),
                        KeszletSzam                 = Convert.ToInt32(((node["Stock"] as XmlNode)["Value"] as XmlElement).InnerText),
                        KulsoKeszletSzam            = Convert.ToInt32(((node["Stock"] as XmlNode)["ExternalStock"] as XmlElement).InnerText),
                        ErtekesitesVege             = Convert.ToBoolean((node["EndOfSales"] as XmlElement).InnerText),
                        KepID                       = (node["PictureId"] as XmlElement).InnerText,
                        Vonalkod                    = (node["BarCode"] as XmlElement).InnerText,
                        HasonloTermekID             = (node["PtaSimilarProduct"] as XmlElement).InnerText
                    };

#if CSAKNOTEBOOK
                    if (!termek.ElsoKategoriaID.Equals("M001") || !termek.MasodikKategoriaID.Equals("N001"))
                    {
                        continue;
                    }
#endif

                    if (_endofsaleseldob && termek.ErtekesitesVege)
                    {
                        continue;
                    }

                    //termek.Megnevezes = termek.Megnevezes.Replace('\n', ',').Replace('\r', ',');
                    termek.Leiras = termek.Leiras.Replace('\n', ',').Replace('\r', ',');

                    string tempstr = (node["Price"] as XmlElement).InnerText; termek.Ar = Convert.ToInt32((tempstr.Substring(0, tempstr.Length - 4)));

                    tempstr = (node["NetWeight"] as XmlElement).InnerText; if (!string.IsNullOrEmpty(tempstr))
                    {
                        termek.NettoSuly = Convert.ToDouble(tempstr, System.Globalization.CultureInfo.InvariantCulture);
                    }
                    tempstr = (node["GrossWeight"] as XmlElement).InnerText; if (!string.IsNullOrEmpty(tempstr))
                    {
                        termek.BruttoSuly = Convert.ToDouble(tempstr, System.Globalization.CultureInfo.InvariantCulture);
                    }
                    tempstr = (node["GrossWidth"] as XmlElement).InnerText; if (!string.IsNullOrEmpty(tempstr))
                    {
                        termek.Szelesseg = Convert.ToDouble(tempstr, System.Globalization.CultureInfo.InvariantCulture);
                    }
                    tempstr = (node["GrossHeight"] as XmlElement).InnerText; if (!string.IsNullOrEmpty(tempstr))
                    {
                        termek.Magassag = Convert.ToDouble(tempstr, System.Globalization.CultureInfo.InvariantCulture);
                    }
                    tempstr = (node["GrossDepth"] as XmlElement).InnerText; if (!string.IsNullOrEmpty(tempstr))
                    {
                        termek.Hossz = Convert.ToDouble(tempstr, System.Globalization.CultureInfo.InvariantCulture);
                    }

                    termek.LetoltesIdopontja = DateTime.Now;

                    Globalisok.Munkaasztal.FrissTermekLista.Add(termek);
                }

                lekertelemszam += termeknodes.Count;
                FolyamatValtozott?.Invoke(lekertelemszam, elemszam, string.Format("{0}/{1} termék lekérve ({2:P2})", lekertelemszam, elemszam, (double)lekertelemszam / (double)elemszam));

                ++oldalszam;
            } while (elemszam != 0);

            FolyamatValtozott?.Invoke(1, 1, "A termékek letöltése sikeresen végbement.");

            // Kategóriák kinyerése a friss terméklistából
            KategoriakTermeklistabol(Globalisok.Munkaasztal.FrissTermekLista);

            // Kategóriák szinkornizálása a kategória-megfeleltető listával
            Model.KategoriaMegfeleltetes.HRPKategoriakatSzinkronizal();
        }
示例#5
0
        /// <summary>
        /// Excel fájlba exportálja a paraméterként megadott terméklistát WHosting szerinti összeállításban a munkamappába, vagy a paraméterként megadott mappába.
        /// Az exportált fájl neve a beállításokban megadott fájlnévből és az aktuális dátumból képződik (YYYYMMDD).
        /// A metódus kérdezés nélkül felülírja a létező listát.
        /// </summary>
        /// <param name="_termekek">A terméklista amelyet exportálni kívánunk.</param>
        /// <param name="_elteromappa">Itt lehetséges megadni az eltérő mappát, ha nem a munkamappába kívánjuk exportálni a terméklistát.</param>
        /// <returns></returns>
        public static async Task FajlbaExportal(IList <Termek> _termekek, CancellationToken _canceltoken, string _elteromappa = null)
        {
            if (_termekek == null)
            {
                throw new ArgumentNullException(nameof(_termekek));
            }
            if (_canceltoken == null)
            {
                throw new ArgumentNullException(nameof(_canceltoken));
            }

            FolyamatValtozott?.Invoke(0, 0, string.Format("{0}/{1} termék exportálva ({2:P2})", 0, 0, 0));

            XLWorkbook   wb = new XLWorkbook();
            IXLWorksheet ws = wb.AddWorksheet("Products");
            int          ctr = 1, osszestermekszam = Globalisok.Munkaasztal.HRPTermekLista.Count;

            // Oszlopok szélességének beállítása
            int[] oszlopszelessegek = new int[] { 10, 30, 30, 12,
                                                  10, 12, 14, 13, 13, 15, 10,
                                                  8, 8, 12, 12, 8, 10,
                                                  6, 19, 19, 14,
                                                  6, 11, 8, 8, 8, 11,
                                                  6, 12,
                                                  32, 32, 20, 20, 32, 32, 32, 32,
                                                  15, 16, 16, 16, 32, 32,
                                                  10, 8, 8 };

            foreach (int szelesseg in oszlopszelessegek)
            {
                ws.Column(ctr++).Width = szelesseg;
            }

            // Fejléc hozzáadása
            string[] fejlec = new string[]
            {
                "product_id", "name(en-gb)", "name(hu-hu)", "categories",
                "sku", "upc", "ean", "jan", "isbn", "mpn", "location",
                "quantity", "model", "manufacturer", "image_name", "shipping", "price",
                "points", "date_added", "date_modified", "date_available",
                "weight", "weight_unit", "length", "width", "height", "length_unit",
                "status", "tax_class_id",
                "description(en-gb)", "description(hu-hu)", "meta_title(en-gb)", "meta_title(hu-hu)", "meta_description(en-gb)", "meta_description(hu-hu)", "meta_keywords(en-gb)", "meta_keywords(hu-hu)",
                "stock_status_id", "store_ids", "layout", "related_ids", "tags(en-gb)", "tags(hu-hu)",
                "sort_order", "subtract", "minimum"
            };

            ctr = 1;

            foreach (string fln in fejlec)
            {
                IXLCell cell = ws.Cell(1, ctr++);

                cell.SetValue(fln);
                cell.Style.Font.Bold            = true;
                cell.Style.Fill.BackgroundColor = XLColor.FromArgb(189, 215, 238);
            }

            // Termékek hozzáadása
            await Task.Run(async() =>
            {
                DateTime most = DateTime.Now;
                ctr           = 2;

                foreach (Termek termek in _termekek)
                {
                    if (_canceltoken.IsCancellationRequested)
                    {
                        break;
                    }

                    // Cellák tartalmainak feltöltése
                    ws.Cell(ctr, 1).SetValue(termek.product_id);
                    ws.Cell(ctr, 2).SetValue(termek.name_engb);
                    ws.Cell(ctr, 3).SetValue(termek.name_huhu);
                    //ws.Cell(ctr,  4).SetValue(termek.categories);
                    ws.Cell(ctr, 5).SetValue(termek.sku);
                    //ws.Cell(ctr,  6).SetValue(termek.upc);
                    ws.Cell(ctr, 7).SetValue(termek.ean);
                    //ws.Cell(ctr,  8).SetValue(termek.jan);
                    //ws.Cell(ctr,  9).SetValue(termek.isbn);
                    ws.Cell(ctr, 10).SetValue(termek.mpn);
                    //ws.Cell(ctr, 11).SetValue(termek.location);
                    ws.Cell(ctr, 12).SetValue(termek.quantity);
                    ws.Cell(ctr, 13).SetValue(termek.model);
                    ws.Cell(ctr, 14).SetValue(termek.manufacturer);
                    //ws.Cell(ctr, 15).SetValue(termek.image_name);
                    ws.Cell(ctr, 16).SetValue(termek.shipping);
                    ws.Cell(ctr, 17).SetValue(termek.price);
                    ws.Cell(ctr, 18).SetValue(termek.points);
                    ws.Cell(ctr, 19).SetValue(termek.date_added);
                    ws.Cell(ctr, 20).SetValue(termek.date_modified);
                    ws.Cell(ctr, 21).SetValue(termek.date_available);
                    ws.Cell(ctr, 22).SetValue(termek.weight);
                    ws.Cell(ctr, 23).SetValue(termek.weight_unit);
                    ws.Cell(ctr, 24).SetValue(termek.length);
                    ws.Cell(ctr, 25).SetValue(termek.width);
                    ws.Cell(ctr, 26).SetValue(termek.height);
                    ws.Cell(ctr, 27).SetValue(termek.length_unit);
                    ws.Cell(ctr, 28).SetValue(termek.shipping);
                    ws.Cell(ctr, 29).SetValue(termek.tax_class_id);
                    ws.Cell(ctr, 30).SetValue(termek.description_engb);
                    ws.Cell(ctr, 31).SetValue(termek.description_huhu);
                    ws.Cell(ctr, 32).SetValue(termek.meta_title_engb);
                    ws.Cell(ctr, 33).SetValue(termek.meta_title_huhu);
                    ws.Cell(ctr, 34).SetValue(termek.meta_description_engb);
                    ws.Cell(ctr, 35).SetValue(termek.meta_description_huhu);
                    ws.Cell(ctr, 36).SetValue(termek.meta_keywords_engb);
                    ws.Cell(ctr, 37).SetValue(termek.meta_keywords_huhu);
                    ws.Cell(ctr, 38).SetValue(termek.stock_status_id);
                    ws.Cell(ctr, 39).SetValue(termek.store_ids);
                    //ws.Cell(ctr, 40).SetValue(termek.layout);
                    //ws.Cell(ctr, 41).SetValue(termek.related_ids);
                    ws.Cell(ctr, 42).SetValue(termek.tags_engb);
                    ws.Cell(ctr, 43).SetValue(termek.tags_huhu);
                    ws.Cell(ctr, 44).SetValue(termek.sort_order);
                    ws.Cell(ctr, 45).SetValue(termek.subtract);
                    ws.Cell(ctr, 46).SetValue(termek.minimum);

                    // Horizontális igazítás
                    ws.Cell(ctr, 17).Style.Alignment.Horizontal     =
                        ws.Cell(ctr, 22).Style.Alignment.Horizontal = XLAlignmentHorizontalValues.Right;

                    // Cellaformátumok beállítása
                    ws.Cell(ctr, 17).DataType     =
                        ws.Cell(ctr, 22).DataType = XLDataType.Number;
                    //ws.Cell(ctr, 17).Style.NumberFormat.Format = "# ##0,00";
                    //ws.Cell(ctr, 22).Style.NumberFormat.Format = "# ##0,00";

                    if ((ctr - 1) % 25 == 0)
                    {
                        FolyamatValtozott?.Invoke(ctr - 1, osszestermekszam, string.Format("{0}/{1} termék exportálva ({2:P2})", ctr - 1, osszestermekszam, (double)(ctr - 1) / (double)osszestermekszam));
                    }

                    ++ctr;
                }

                // Fejléc sora és az első oszlop rögzítve legyen
                ws.SheetView.FreezeRows(1);
                ws.SheetView.FreezeColumns(1);

                if (!_canceltoken.IsCancellationRequested)
                {
                    FolyamatValtozott?.Invoke(1, 1, "Fájlba írás...");

                    StorageFolder folder = await StorageFolder.GetFolderFromPathAsync(_elteromappa ?? Globalisok.Mappa_Termeklista);
                    StorageFile file     = await folder.CreateFileAsync(Fajlnev, CreationCollisionOption.ReplaceExisting);

                    using (Stream filestream = await file.OpenStreamForWriteAsync())
                    {
                        wb.SaveAs(filestream);
                        filestream.Close();
                    }

                    FolyamatValtozott?.Invoke(1, 1, "A termékek exportálása sikeresen végbement.");
                }
            });
        }
示例#6
0
        /// <summary>
        /// Excel fájlba exportálja a paraméterként megadott terméklistát HRP szerinti összeállításban a munkamappába, vagy a paraméterként megadott mappába.
        /// Az exportált fájl neve a beállításokban megadott fájlnévből és az aktuális dátumból képződik (YYYYMMDD).
        /// A metódus kérdezés nélkül felülírja a létező listát.
        /// </summary>
        /// <param name="_termekek">A terméklista amelyet exportálni kívánunk.</param>
        /// <param name="_elteromappa">Itt lehetséges megadni az eltérő mappát, ha nem a munkamappába kívánjuk exportálni a terméklistát.</param>
        /// <returns></returns>
        public static async Task FajlbaExportal_HRP(IList <Model.Termek> _termekek, CancellationToken _canceltoken, string _elteromappa = null)
        {
            if (_termekek == null)
            {
                throw new ArgumentNullException(nameof(_termekek));
            }
            if (_canceltoken == null)
            {
                throw new ArgumentNullException(nameof(_canceltoken));
            }

            FolyamatValtozott?.Invoke(0, 0, string.Format("{0}/{1} termék exportálva ({2:P2})", 0, 0, 0));

            XLWorkbook   wb = new XLWorkbook();
            IXLWorksheet ws = wb.AddWorksheet("Termékek");
            int          ctr = 1, osszestermekszam = Globalisok.Munkaasztal.TermekLista.Count;

            // Oszlopok szélességének beállítása
            int[] oszlopszelessegek = new int[] { 17, 17, 70, 19, 14, 8, 14, 8, 14, 8, 14,
                                                  16, 11, 10, 8, 8,
                                                  13, 8, 8, 8, 8, 15,
                                                  8, 8, 8, 8 };

            foreach (int szelesseg in oszlopszelessegek)
            {
                ws.Column(ctr++).Width = szelesseg;
            }

            // Fejléc hozzáadása
            string[] fejlec = new string[]
            {
                "ID", "Cikkszám", "Megnevezés", "Leírás", "Gyártó", "Ktg#1 ID", "Kategória #1", "Ktg#2 ID", "Kategória #2", "Ktg#3 ID", "Kategória #3",
                "Garancia mód", "Garancia idő", "Ár", "Új", "Kedvezmény",
                "Készletinfó", "Van raktáron", "Készletszám", "Külső készletszám", "Értékesítés vége", "Vonalkód",
                "Nettó súly", "Bruttó súly", "Szélesség", "Magasság", "Hossz"
            };

            ctr = 1;

            foreach (string fln in fejlec)
            {
                IXLCell cell = ws.Cell(1, ctr++);

                cell.SetValue(fln);
                cell.Style.Font.Bold            = true;
                cell.Style.Fill.BackgroundColor = XLColor.FromArgb(189, 215, 238);
            }

            // Termékek hozzáadása
            await Task.Run(async() =>
            {
                ctr = 2;

                foreach (Termek termek in _termekek)
                {
#if CSAKNOTEBOOK
                    if (!termek.ElsoKategoriaID.Equals("M001") || !termek.MasodikKategoriaID.Equals("N001"))
                    {
                        continue;
                    }
#endif

                    if (_canceltoken.IsCancellationRequested)
                    {
                        break;
                    }

                    // A sor betűinek színe szürke, ha nincs forgalmazva a termék
                    if (termek.ErtekesitesVege)
                    {
                        foreach (var cell in ws.Range(ctr, 1, ctr, 27).Cells())
                        {
                            cell.Style.Font.FontColor = XLColor.Gray;
                        }
                    }

                    // Cellák tartalmainak feltöltése
                    ws.Cell(ctr, 1).SetValue(termek.ID);
                    ws.Cell(ctr, 2).SetValue(termek.Cikkszam);
                    ws.Cell(ctr, 3).SetValue(termek.Megnevezes);
                    ws.Cell(ctr, 4).SetValue(termek.Leiras);
                    ws.Cell(ctr, 5).SetValue(termek.GyartoMegnevezes);
                    ws.Cell(ctr, 6).SetValue(termek.ElsoKategoriaID);
                    ws.Cell(ctr, 7).SetValue(termek.ElsoKategoriaMegnevezes);
                    ws.Cell(ctr, 8).SetValue(termek.MasodikKategoriaID);
                    ws.Cell(ctr, 9).SetValue(termek.MasodikKategoriaMegnevezes);
                    ws.Cell(ctr, 10).SetValue(termek.HarmadikKategoriaID);
                    ws.Cell(ctr, 11).SetValue(termek.HarmadikKategoriaMegnevezes);
                    ws.Cell(ctr, 12).SetValue(termek.GaranciaMod);
                    ws.Cell(ctr, 13).SetValue(termek.GaranciaIdo);
                    ws.Cell(ctr, 14).SetValue(termek.Ar);
                    ws.Cell(ctr, 15).SetValue(termek.Uj ? "igen" : "nem"); ws.Cell(ctr, 12).Style.Font.FontColor         = termek.Uj ? XLColor.Green : XLColor.Red;
                    ws.Cell(ctr, 16).SetValue(termek.Kedvezmeny ? "igen" : "nem"); ws.Cell(ctr, 13).Style.Font.FontColor = termek.Kedvezmeny ? XLColor.Green : XLColor.Red;
                    ws.Cell(ctr, 17).SetValue(termek.KeszletInfo);
                    ws.Cell(ctr, 18).SetValue(termek.VanRaktaron ? "igen" : "nem"); ws.Cell(ctr, 15).Style.Font.FontColor = termek.VanRaktaron ? XLColor.Green : XLColor.Red;
                    ws.Cell(ctr, 19).SetValue(termek.KeszletSzam);
                    ws.Cell(ctr, 20).SetValue(termek.KulsoKeszletSzam);
                    ws.Cell(ctr, 21).SetValue(termek.ErtekesitesVege ? "igen" : "nem"); ws.Cell(ctr, 18).Style.Font.FontColor = termek.ErtekesitesVege ? XLColor.Green : XLColor.Red;
                    ws.Cell(ctr, 22).SetValue(termek.Vonalkod);
                    ws.Cell(ctr, 23).SetValue(termek.NettoSuly.ToString());
                    ws.Cell(ctr, 24).SetValue(termek.BruttoSuly.ToString());
                    ws.Cell(ctr, 25).SetValue(termek.Szelesseg.ToString());
                    ws.Cell(ctr, 26).SetValue(termek.Magassag.ToString());
                    ws.Cell(ctr, 27).SetValue(termek.Hossz.ToString());

                    // Horizontális igazítás
                    ws.Cell(ctr, 14).Style.Alignment.Horizontal                             =
                        ws.Cell(ctr, 19).Style.Alignment.Horizontal                         =
                            ws.Cell(ctr, 20).Style.Alignment.Horizontal                     =
                                ws.Cell(ctr, 23).Style.Alignment.Horizontal                 =
                                    ws.Cell(ctr, 24).Style.Alignment.Horizontal             =
                                        ws.Cell(ctr, 25).Style.Alignment.Horizontal         =
                                            ws.Cell(ctr, 26).Style.Alignment.Horizontal     =
                                                ws.Cell(ctr, 27).Style.Alignment.Horizontal = XLAlignmentHorizontalValues.Right;

                    // Cellaformátumok beállítása
                    ws.Cell(ctr, 14).DataType = XLDataType.Number;

                    if ((ctr - 1) % 25 == 0)
                    {
                        FolyamatValtozott?.Invoke(ctr - 1, osszestermekszam, string.Format("{0}/{1} termék exportálva ({2:P2})", ctr - 1, osszestermekszam, (double)(ctr - 1) / (double)osszestermekszam));
                    }

                    ++ctr;
                }

                // Fejléc sora rögzítve legyen
                ws.SheetView.FreezeRows(1);

                if (!_canceltoken.IsCancellationRequested)
                {
                    FolyamatValtozott?.Invoke(1, 1, "Fájlba írás...");

                    StorageFolder folder = await StorageFolder.GetFolderFromPathAsync(_elteromappa ?? Globalisok.Mappa_Termeklista);
                    StorageFile file     = await folder.CreateFileAsync(FajlnevHRP, CreationCollisionOption.ReplaceExisting);

                    using (Stream filestream = await file.OpenStreamForWriteAsync())
                    {
                        wb.SaveAs(filestream);
                        filestream.Close();
                    }

                    FolyamatValtozott?.Invoke(1, 1, "A termékek exportálása sikeresen végbement.");
                }
            });
        }