kashiash
3/18/2019 - 8:42 AM

Import z excela #devexpress #xaf

Import z excela #devexpress #xaf

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
using DevExpress.Spreadsheet;


using System.IO;

using DevExpress.Data.Filtering;
using DevExpress.Xpo;
using DevExpress.ExpressApp;
using DevExpress.ExpressApp.Win;
using System.Threading;
using System.Globalization;

namespace kashiash.utils
{

    public interface IImportujeExcela
    {
        void WczytajWiersz(int i, ExcelImporterHelper importHelper);

        IObjectSpace ObjectSpace { set; }
    }

    public abstract class ExcelImporter : IImportujeExcela
    {
        public IObjectSpace objectSpace = null;

        public IObjectSpace ObjectSpace
        {
            set
            {
                objectSpace = value;
            }
        }



        public abstract void WczytajWiersz(int i, ExcelImporterHelper importHelper);

    }


    public class ExcellImporter : IDisposable
    {

        Workbook workbook = null;
        Worksheet worksheet = null;
        IObjectSpace objectSpace = null;
        IImportujeExcela importer = null;
        ExcelImporterHelper importHelper = null;
        string IdentifyString = string.Empty;
        int startRow = 0;
        WinApplication winApplication = null;

        private readonly string[,] splashUpdates = new string[,]{
                                                    { "Prosze czekać...", "Rozpoczynamy..." },
                                                    { "A bit more...", "Wczytuję dane..." },
                                                    { "Trwa zapisywanie do bazy!", "Kończymy..." } };




        public ExcellImporter(IObjectSpace os)
        {
            objectSpace = os;
        }

        public ExcellImporter(IImportujeExcela ie, int headerRow, string identify)
        {
            IdentifyString = identify;
            startRow = headerRow;
            importer = ie;
        }


        public ExcellImporter(IObjectSpace os, IImportujeExcela ie, string identify)
        {
            objectSpace = os;
            importer = ie;

            IdentifyString = identify;
        }

        public ExcellImporter(IObjectSpace os, IImportujeExcela ie, WinApplication wap, string identify)
        {
            objectSpace = os;
            importer = ie;

            IdentifyString = identify;

            winApplication = wap;
        }

        public ExcellImporter(IObjectSpace os, IImportujeExcela ie, WinApplication wap, int headerRow, string identify)
        {
            objectSpace = os;
            importer = ie;

            IdentifyString = identify;
            startRow = headerRow;
            winApplication = wap;


        }
        public string[] PobierzPliki()
        {

            OpenFileDialog openFileDialog1 = new OpenFileDialog();

            openFileDialog1.Filter = "(*.xls)|*.xls|(*.xlsx)|*.xlsx|All files (*.*)|*.*";
            // openFileDialog1.FilterIndex = 1;
            openFileDialog1.RestoreDirectory = true;
            openFileDialog1.Multiselect = true;

            if (openFileDialog1.ShowDialog() == DialogResult.OK)
            {

                return openFileDialog1.FileNames;
            }

            return new string[0];
        }


        public void Execute()
        {
            if (winApplication != null)
            {
                // Set the WinApplication.SplashScreen property to provide a splash screen for your application.
                winApplication.SplashScreen = new DevExpress.ExpressApp.Win.Utils.DXSplashScreen();
                // Call the SetDisplayText to provide the initial display text for your splash screen.
                winApplication.SplashScreen.SetDisplayText(splashUpdates[0, 0]);
            }
            string[] pliki = PobierzPliki();

            foreach (string fileName in pliki)
            {
                if (winApplication != null)
                {
                    winApplication.StartSplash();
                    ((ISupportUpdateSplash)winApplication.SplashScreen).UpdateSplash(splashUpdates[0, 0], splashUpdates[0, 1]);
                }
                try
                {
                    Importuj(fileName);
                }
                finally
                {
                    if (winApplication != null)
                    {
                        ((ISupportUpdateSplash)winApplication.SplashScreen).UpdateSplash(splashUpdates[2, 0], splashUpdates[2, 1]);
                        winApplication.StopSplash();
                    }
                }
            }
            if (winApplication != null)
            {
                ((ISupportUpdateSplash)winApplication.SplashScreen).UpdateSplash(splashUpdates[2, 0], splashUpdates[2, 1]);
                winApplication.StopSplash();
            }
        }

        public void Execute(string fileName)
        {

            try
            {
                Importuj(fileName);
            }
            finally
            {

            }
        }

        private void Importuj(string excelFilePath)
        {
            if (objectSpace != null)
            {
                importer.ObjectSpace = objectSpace;
            }
            if (!File.Exists(excelFilePath)) throw new FileNotFoundException(excelFilePath);

            using (workbook = new Workbook())
            {
                workbook.LoadDocument(excelFilePath);
                worksheet = workbook.Worksheets[0];
                using (importHelper = new ExcelImporterHelper(worksheet))
                {
                    Cell Rodzaj = worksheet.Rows[0]["A"];
                 if (winApplication != null)
                    {
                        ((ISupportUpdateSplash)winApplication.SplashScreen).UpdateSplash(excelFilePath, splashUpdates[1, 1]);
                    }
                    if (IdentifyString == string.Empty || Rodzaj.Value.ToString().Trim() == IdentifyString)
                    {
                        Range usedRange = worksheet.GetUsedRange();
                        int lk = usedRange.RowCount;
                        int prog = 30;
                        for (int i = 1; i < lk; i++)
                        {
                            if (i >= startRow)
                            {
                                if (winApplication != null)
                                {
                                    if (i / lk * 100 > prog)
                                    {
                                        prog += 10;
                                        string description = $"{excelFilePath} {prog}%%";
                                        ((ISupportUpdateSplash)winApplication.SplashScreen).UpdateSplash(excelFilePath, description);
                                    }
                                }
                                importer.WczytajWiersz(i, importHelper);
                            }
                        }

                        if (winApplication != null)
                        {
                            ((ISupportUpdateSplash)winApplication.SplashScreen).UpdateSplash(splashUpdates[2, 0], splashUpdates[2, 1]);
                        }
                        if (objectSpace != null)
                        {
                            objectSpace.CommitChanges();
                            objectSpace.Refresh();
                        }
                    }
                }
            }
        }

        public void Dispose()
        {
            //
        }
    }

    public class ExcelImporterHelper : IDisposable
    {
        Worksheet worksheet = null;
        public ExcelImporterHelper(Worksheet _worksheet)
        {
            worksheet = _worksheet;
        }


        public DateTime GetCellDateValue(int i, string v)
        {
            Cell dataCell = worksheet.Rows[i][v];
            return kashiash.utils.XUtilConvert.ParsujDate(dataCell.Value.ToString().Trim());
        }
        public decimal GetCellDecimalValue(int i, string v)
        {
            Cell decimalCell = worksheet.Rows[i][v];
            return System.Convert.ToDecimal(decimalCell.Value.NumericValue);
        }


        public decimal GetCellDecimalValue(int i, string v, string culture)
        {
            Cell decimalCell = worksheet.Rows[i][v];
            return decimal.Parse(decimalCell.Value.ToString().Trim(), new CultureInfo(culture));
        }
        public string GetCellStringValue(int i, string v)
        {
            Cell stringCell = worksheet.Rows[i][v];
            return stringCell.Value.ToString().Trim();
        }
        public int GetCellIntValue(int i, string v)
        {
            Cell cell = worksheet.Rows[i][v];
            return kashiash.utils.XUtilConvert.ObjectToInt(cell.Value.ToString().Trim());
        }

        public void Dispose()
        {
            //this.Dispose();
        }
    }
}


using DevExpress.Data.Filtering;
using DevExpress.ExpressApp;
using DevExpress.Xpo;

using kashiash.utils;
using Uta.Module.BusinessObjects;
using Uta.Module.BusinessObjects.Urzadzenia;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Uta.Module.Utils
{
    public class UtaOneImporter : ExcelImporter
    {


        public override void WczytajWiersz(int i, ExcelImporterHelper importHelper)
        {
            try
            {

               ImportujWiersz(i, importHelper);


            }
            catch (Exception ex)
            {

                Console.WriteLine(ex.ToString());
            }
            objectSpace.CommitChanges();
        }

        private void ImportujWiersz(int i, ExcelImporterHelper importHelper)
        {
          
            try
            {
                //  int  = importHelper.GetCellIntValue(i, "B");
                //Numer klienta   

                UtaOne res = ZnajdzDuplikat(i,importHelper);
                if (res == null)
                {
                    UtaOne pn = objectSpace.CreateObject<UtaOne>();
                    if (importHelper.GetCellStringValue(0, "O") == "Kontextauswahl")
                    {
                            PrzepiszDaneZExcelaA(i, importHelper, pn);
                    }
                    else if (importHelper.GetCellStringValue(0, "O") == "Erstellt am")
                    {
                        PrzepiszDaneZExcelaB(i, importHelper, pn);
                    }
                    else
                    {
                        throw new Exception("Nieznany format excela");
                    }
                    if (pn.Kraje.ToUpper() != "STANDARD")
                    {
                        ParsujKonteksty(pn);
                        pn.RodzajUrzadzenia = RodzajUrzadzenia.UtaOne;
                    }
                    else
                    {
                        pn.RodzajUrzadzenia = RodzajUrzadzenia.TelepassUE;
                    }
                    pn.Status = objectSpace.GetObjectByKey<StatusUtaOne>(1);
                    pn.Save();
                }

            }
            catch (Exception)
            {
                throw;
            }

        
        }

        private UtaOne ZnajdzDuplikat(int i,ExcelImporterHelper importHelper)
        {
            string NrRejestracyjny = importHelper.GetCellStringValue(i, "G");
            DateTime DataUtworzenia = DateTime.MinValue;
            if (importHelper.GetCellStringValue(0, "O") == "Kontextauswahl")
            {
                 DataUtworzenia = importHelper.GetCellDateValue(i, "H");
            }
            else if (importHelper.GetCellStringValue(0, "O") == "Erstellt am")
            {
                 DataUtworzenia = importHelper.GetCellDateValue(i, "O");
            }
            return objectSpace.FindObject<UtaOne>(CriteriaOperator.Parse("NrRejestracyjny = ? And DataUtworzenia = ?", NrRejestracyjny, DataUtworzenia));
        }

        private void PrzepiszDaneZExcelaA(int i, ExcelImporterHelper importHelper, UtaOne pn)
        {


            int nrKlienta = importHelper.GetCellIntValue(i, "C");
            pn.Klient = objectSpace.GetObjectByKey<Klienci>(nrKlienta);
            //    skrócony adres  
            pn.SkroconyAdres = importHelper.GetCellStringValue(i, "E");
            //    rabat 
            pn.Rabat = importHelper.GetCellStringValue(i, "F");
            //    nr rejestracyjny 
            pn.NrRejestracyjny = importHelper.GetCellStringValue(i, "G");
            //    data utworzenia
            pn.DataUtworzenia = importHelper.GetCellDateValue(i, "H");
            //    VIN     
            pn.VIN = importHelper.GetCellStringValue(i, "I");
            // Kraj
            string kraj = importHelper.GetCellStringValue(i, "J");
            Kraje res = objectSpace.FindObject<Kraje>

                  (CriteriaOperator.Parse(string.Format(@"SKROTKRAJU ='{0}'", kraj)));
            pn.Kraj = res; // objectSpace.GetObjectByKey<Kraje>(res);

            //    Masa ciągnika   
            pn.MasaCiagnika = importHelper.GetCellIntValue(i, "K");
            //    Masa zestawu    
            pn.MasaZestawu = importHelper.GetCellIntValue(i, "L");
            //    klasa emisji spalin 
            pn.KlasaEmisjiSpalin = importHelper.GetCellStringValue(i, "M");
            //    rodzaj pojazdu 
            pn.RodzajPojazdu = importHelper.GetCellStringValue(i, "N");
            //    kraje  
            pn.Kraje = importHelper.GetCellStringValue(i, "O");

        }

        private void PrzepiszDaneZExcelaB(int i, ExcelImporterHelper importHelper, UtaOne pn)
        {


            int nrKlienta = importHelper.GetCellIntValue(i, "C");
            pn.Klient = objectSpace.GetObjectByKey<Klienci>(nrKlienta);
            //    skrócony adres  
            pn.SkroconyAdres = importHelper.GetCellStringValue(i, "E");
            //    rabat 
            pn.Rabat = importHelper.GetCellStringValue(i, "F");
            //    nr rejestracyjny 
            pn.NrRejestracyjny = importHelper.GetCellStringValue(i, "G");
            //    VIN     
            pn.VIN = importHelper.GetCellStringValue(i, "H");
            // Kraj
            string kraj = importHelper.GetCellStringValue(i, "I");
            Kraje res = objectSpace.FindObject<Kraje>

                  (CriteriaOperator.Parse(string.Format(@"SKROTKRAJU ='{0}'", kraj)));
            pn.Kraj = res; // objectSpace.GetObjectByKey<Kraje>(res);

            //    Masa ciągnika   
            pn.MasaCiagnika = importHelper.GetCellIntValue(i, "J");
            //    Masa zestawu    
            pn.MasaZestawu = importHelper.GetCellIntValue(i, "K");
            //    klasa emisji spalin 
            pn.KlasaEmisjiSpalin = importHelper.GetCellStringValue(i, "L");
            //    rodzaj pojazdu 
            pn.RodzajPojazdu = importHelper.GetCellStringValue(i, "M");
            //    kraje  
            pn.Kraje = importHelper.GetCellStringValue(i, "N");
            //    data utworzenia
            pn.DataUtworzenia = importHelper.GetCellDateValue(i, "O");
        }

        private void ParsujKonteksty(UtaOne pn)
        {
            Char delimiter = ',';
            String[] substrings = pn.Kraje.Split(delimiter);
            foreach (var substring in substrings)
            {
                DodajKontekst(pn, substring);
            }
        }

        private void DodajKontekst(UtaOne pn, string kontekst)
        {
            if (string.IsNullOrEmpty(kontekst))
            {
                return;
            }
            Kraje knt = objectSpace.FindObject<Kraje>(CriteriaOperator.Parse($"SymbolKontekstu = '{kontekst}'"));
            if (knt == null)
            {
                knt = objectSpace.CreateObject<Kraje>();
                knt.SymbolKontekstu = kontekst;
                knt.Save();

            }
            pn.KrajeCollection.Add(knt);

        }

    }
}
     public void GetFilesToProcess()
        {
            try
            {
                IQueryable<SodSkany> query = objectSpace.GetObjectsQuery<SodSkany>(true);
                IQueryable<SodSkany> zalaczniki = query.Where(zalacznik
                    => zalacznik.Przetworzony == false
                    && zalacznik.File.FileName.IndexOf(".xls") > 0 &&
                     zalacznik.ReceivedMessage.MailAccount == "approval@uta.pl");

                _logger.Trace("Liczba załaczników  do przetworzenia: {0}", zalaczniki.Count());
                foreach (SodSkany zalacznik in zalaczniki)
                {
                    _logger.Trace(" przetwarzam: {0} ", zalacznik.File.FileName);
                    if (!zalacznik.Przetworzony )
                    {
                        importedFile = zalacznik.File.FileName;
                        string filename = ZapiszPlik(zalacznik.File);

                        Import(filename);
                        var rec = objectSpace.GetObject<SodSkany>(zalacznik);
                        rec.Przetworzony = true;
                        rec.Save();
                        objectSpace.CommitChanges();
                        objectSpace.Refresh();
                        return; // przerywamy aby w jednym przebiegu zaimportowalo tylko 1 plik
                    }
                    else
                    {
                        _logger.Trace("Pomijam {1} bo przetworzony: {0} lub nie jest plikiem excel", zalacznik.CreatedOn, zalacznik.File.FileName);
                    }
                }
            }
            catch (Exception ex)
            {
                _logger.Error(ex, "Wyjatek podczas przetwarzania załaczników");
                //TODO: dodac kod wysyłajacy maila armamowego
                MailSender.SendEmail("Bład podczas importu UtaOne " + importedFile, ex.ToString(), "jacek.kosinski@uta.pl");
            }
        }
        internal static void ProcessUtaOneImport()
        {
            try
            {
                _logger.Trace("Uta One Import data");
                using (XPObjectSpaceProvider directProvider = new XPObjectSpaceProvider(AppConfig.ConnectionString, null))
                {
                    using (IObjectSpace directObjectSpace = directProvider.CreateObjectSpace())
                    {
                        using (UtaOneProcessor proc = new UtaOneProcessor(directObjectSpace))
                        {
                            proc.GetFilesToProcess();
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                MailSender.SendEmail("Wystąpił wyjątek ", ex.ToString(), "bllabla@gmail.com");
             
            }
        }