예제 #1
0
        /// <summary>
        /// Funzione richiamata dal Thread per l'esecuzione dell'importazione
        /// </summary>
        /// <param name="prameters">Un array di oggetti. Sono attesi 4 elementi:
        ///     - Il primo deve essere un oggetto di tipo AddressBookRowDataContainer
        ///     - Il secondo deve essere un oggetto di tipo string
        ///     - Il terzo deve essere un oggetto di tipo InfoUtente
        ///     - Il quarto deve essere un oggetto di tipo Ruolo
        /// </param>
        public void ExecuteImport(object parameters)
        {
            #region Dichiarazione variabili

            // L'array dei parametri
            object[] param;

            // L'oggetto con le informazioni sui corrispondenti da importare
            AddressBookRowDataContainer abrdc;

            // L'url del frontend
            string url;

            // Le informazioni sull'utente che ha lanciato la procedura
            InfoUtente userInfo;

            // Il ruolo con cui è stata lanciata la procedura
            Ruolo role;

            // Lista in cui depositare temporaneamente il report
            // di importazione relativo ad un insieme di corrispondenti
            // su cui è stata compiuta la stessa operazione
            List <AddressBookImportResult> tempReport;

            #endregion

            // Casting dell'oggetto a array di oggetti
            param = parameters as object[];

            // Se l'array non contiene quattro elementi, fine esecuzione
            if (param.Length != 4)
            {
                return;
            }

            // Prelevamento delle informazioni sui corrispondenti da creare
            abrdc = param[0] as AddressBookRowDataContainer;

            // Prelevamento dell'url del Fontend
            url = param[1] as string;

            // Prelevamento delle informazioni sull'utente
            userInfo = param[2] as InfoUtente;

            // Prelevamento del ruolo
            role = param[3] as Ruolo;

            // Calcolo del numero totale di corrispondenti su cui compiere operazioni
            this.totalNumberOfElementToImport =
                abrdc.ToDelete.Length +
                abrdc.ToInsert.Length +
                abrdc.ToModify.Length;

            #region Inserimento nuovi corrispondenti

            // Inizializzazione della lista da utilizzare per
            // memorizzare temporaneamente il report sull'inserimento
            // dei corrispondenti
            tempReport = new List <AddressBookImportResult>();

            // Inserimento dei corrispondenti
            foreach (AddressBookRowData rowData in abrdc.ToInsert)
            {
                try
                {
                    tempReport.Add(ImportAddressBookUtils.ImportAddressBookElement(
                                       userInfo,
                                       role,
                                       OperationEnum.I,
                                       rowData));
                }
                catch (Exception e)
                {
                    // In caso di eccezione viene aggiunto un risultato negativo
                    tempReport.Add(new AddressBookImportResult()
                    {
                        Result  = ResultEnum.KO,
                        Message = e.Message
                    });
                }

                // Un corrispondente è stato analizzato
                totalNumberOfAnalyzedElements += 1;
            }

            // Aggiunta di una voce di report con il totale dei corrispondenti
            // importati e non importati
            tempReport.Add(this.GetSummaryElement(tempReport));

            // Salvataggio del report per i corrispondenti da inserire
            report.Inserted = tempReport.ToArray();

            #endregion

            #region Modifica dei corrispondenti

            // Inizializzazione della lista da utilizzare per
            // memorizzare temporaneamente il report sulla modifica dei
            // corrispondenti
            tempReport = new List <AddressBookImportResult>();

            // Modifica dei corrispondenti
            foreach (AddressBookRowData rowData in abrdc.ToModify)
            {
                try
                {
                    tempReport.Add(ImportAddressBookUtils.ImportAddressBookElement(
                                       userInfo,
                                       role,
                                       OperationEnum.M,
                                       rowData));
                }
                catch (Exception e)
                {
                    // In caso di eccezione viene aggiunto un risultato negativo
                    tempReport.Add(new AddressBookImportResult()
                    {
                        Result  = ResultEnum.KO,
                        Message = e.Message
                    });
                }

                // Un corrispondente è stato analizzato
                totalNumberOfAnalyzedElements += 1;
            }

            // Aggiunta di una voce di report con il totale dei corrispondenti
            // modificati e non modificati
            tempReport.Add(this.GetSummaryElement(tempReport));

            // Salvataggio del report per i corrispondenti modificati
            report.Modified = tempReport.ToArray();

            #endregion

            #region Corrispondenti da cancellare

            // Inizializzazione della lista da utilizzare per
            // memorizzare temporaneamente il report sulla cancellazione
            // dei corrispondenti
            tempReport = new List <AddressBookImportResult>();

            // Cancellazione dei corrispondenti
            foreach (AddressBookRowData rowData in abrdc.ToDelete)
            {
                try
                {
                    tempReport.Add(ImportAddressBookUtils.ImportAddressBookElement(
                                       userInfo,
                                       role,
                                       OperationEnum.C,
                                       rowData));
                }
                catch (Exception e)
                {
                    // In caso di eccezione viene aggiunto un risultato negativo
                    tempReport.Add(new AddressBookImportResult()
                    {
                        Message = e.Message,
                        Result  = ResultEnum.KO
                    });
                }

                // Un corrispondente è stato analizzato
                totalNumberOfAnalyzedElements += 1;
            }

            // Aggiunta di una voce di report con il totale dei corrispondenti
            // cancellati e non cancellati
            tempReport.Add(this.GetSummaryElement(tempReport));

            // Salvataggio del report per i corrispondenti cancellati
            report.Deleted = tempReport.ToArray();

            #endregion

            // Sospensione del thread fino a quando non viene letto
            // il report o non passano 1 minuto
            //waitReading.WaitOne(new TimeSpan(0,1,0));
        }
예제 #2
0
        protected void btnImportaCorrispondenti_Click(object sender, EventArgs e)
        {
            #region Definizione variabili

            // Un booleano utilizzato per determinare la validità del
            // file excel
            bool canImport;

            // Il file postato
            HttpPostedFile postedFile;

            // Il content del documento
            byte[] content;

            // Il nome da attribuire al file temporaneo
            string temporaryFileName;

            // Il server path
            string serverPath;

            // L'eventuale errore avvenuto durante la lettura dei dati dal foglio
            string error;

            // L'oggetto con le informazioni sui corrispondenti da importare
            AddressBookRowDataContainer abrdc;

            // L'oggetto cui delegare l'esecuzione dell'importazione
            AsyncImportAddressBookExecutor importExecutor;

            // Oggetto per specificare un thread con parametri
            ParameterizedThreadStart entry;

            // Thread
            Thread thread;

            // Oggetto in cui memorizzare i parametri
            object[] parameters;

            #endregion

            // Prelevamento del file postato
            postedFile = this.fileUploader.PostedFile;

            // Verifica del content type e dell'estensione del file al fine
            // di verificarne la validità
            canImport = (postedFile.ContentType == "application/vnd.ms-excel") &&
                        postedFile.FileName.ToLower().EndsWith("xls");

            // Se la verifica ha avuto esito positivo...
            if (canImport)
            {
                // Prelevamento del contenuto del file
                content = this.fileUploader.FileBytes;

                // Creazione del nome per il file temporaneo
                temporaryFileName = String.Format("{0}.xls",
                                                  Guid.NewGuid().ToString());

                // Prelevamento del serverPath
                serverPath = Utils.getHttpFullPath();

                try
                {
                    // Pulizia del call context
                    CallContextStack.CurrentContext.ContextState["addressBookExporter"] = null;
                    CallContextStack.CurrentContext.ContextState["reportImport"]        = null;

                    // Reset del campo nascosto con il valore da raggiungere.
                    this.hfTargetPerc.Value = "0";

                    // Disassociazione delle sorgenti dati
                    this.grdGenerale.DataSource   = null;
                    this.grdInseriti.DataSource   = null;
                    this.grdModificati.DataSource = null;
                    this.grdCancellati.DataSource = null;
                    this.grdGenerale.DataBind();
                    this.grdInseriti.DataBind();
                    this.grdModificati.DataBind();
                    this.grdCancellati.DataBind();

                    // Reperimento delle informazioni sui corrispondenti da importare
                    abrdc = ImportAddressBookUtils.ReadDataFromExcel(
                        content,
                        Guid.NewGuid().ToString() + ".xls",
                        UserManager.getInfoUtente());

                    // Creazione di un nuovo oggetto cui delegare l'importazione dei corrispondenti
                    importExecutor = new AsyncImportAddressBookExecutor();

                    // Salvataggio dell'oggetto esecutore nel CallContext
                    CallContextStack.CurrentContext.ContextState["addressBookExporter"] = importExecutor;

                    // Creazione del thread con parametri
                    //entry = new ParameterizedThreadStart(importExecutor.ExecuteImport);

                    // Creazione del thread
                    //thread = new Thread(entry);

                    // Creazione dell'array dei parametri
                    //parameters = new object[] {
                    //    drdc,
                    //    Utils.getHttpFullPath(),
                    //    UserManager.getInfoUtente(),
                    //    UserManager.getRuolo()
                    //};

                    // Partenza del thread
                    //thread.Start(parameters);

                    // Avvio del timer
                    //this.tmrUpdateInfo.Enabled = true;

                    importExecutor.ExecuteImport(
                        new object[] {
                        abrdc,
                        Utils.getHttpFullPath(),
                        UserManager.getInfoUtente(),
                        UserManager.getRuolo()
                    });

                    int analyzedCorr, totalCorr;
                    // Si richiedono le statistiche
                    importExecutor.GetStatistics(out analyzedCorr, out totalCorr);

                    // Viene prelevato il report
                    report = importExecutor.GetReport();

                    // Se il report Generale non contiene elementi, viene aggiunto un
                    // result positivo
                    if (report.General == null || report.General.Length == 0)
                    {
                        report.General = new AddressBookImportResult[1];

                        report.General[0] = new AddressBookImportResult()
                        {
                            Result  = ResultEnum.OK,
                            Message = "Nessun messaggio generale da mostrare"
                        };
                    }
                }
                catch (Exception ex)
                {
                    // Creazione di un array di result con un solo elemento
                    // che conterrà il dettaglio dell'eccezione
                    report = new AddressBookImportResultContainer();

                    report.General = new AddressBookImportResult[1];

                    report.General[0] = new AddressBookImportResult()
                    {
                        Result  = ResultEnum.KO,
                        Message = ex.Message,
                    };
                }
            }

            // Associazione degli array dei risultati alle varie griglia
            this.grdGenerale.DataSource   = report.General;
            this.grdInseriti.DataSource   = report.Inserted;
            this.grdModificati.DataSource = report.Modified;
            this.grdCancellati.DataSource = report.Deleted;

            // Binding delle sorgenti dati
            this.grdGenerale.DataBind();
            this.grdInseriti.DataBind();
            this.grdModificati.DataBind();
            this.grdCancellati.DataBind();

            // Si nasconde il popup
            this.mdlPopupWait.Hide();

            // Creazione del data set per l'esportazione del report di importazione
            DataSet dataSet = this.GenerateDataSet(report);

            // Path e nome file del template
            string templateFilePath = Server.MapPath("formatPdfExport.xml");

            // Aggiunta nell call context del file documento  con le informazioni
            // da scivere nel report
            CallContextStack.CurrentContext.ContextState["reportImport"] =
                global::ProspettiRiepilogativi.Frontend.PdfReport.do_MakePdfReport(
                    global::ProspettiRiepilogativi.Frontend.ReportDisponibili.ReportLogMassiveImport,
                    templateFilePath,
                    dataSet,
                    null);

            // Abilitazione pulsante esportazione
            this.btnEsportaReport.Enabled = true;

            // Aggiornamento pannello bottoniera
            this.upButtons.Update();
        }