Exemple #1
0
        /// <summary>
        /// Funzione per l'importazione di documenti definiti all'interno di un file Excel
        /// </summary>
        /// <param name="content"></param>
        /// <param name="fileName"></param>
        /// <param name="serverPath"></param>
        /// <param name="modelPath"></param>
        /// <param name="userInfo"></param>
        /// <param name="role"></param>
        /// <param name="isProfilationRequired"></param>
        /// <param name="isRapidClassificationRequired"></param>
        /// <param name="sharedDirectoryPath"></param>
        /// <param name="isSmistamentoEnabled"></param>
        /// <returns></returns>
        public static ResultsContainer ImportDocuments(
            byte[] content,
            string fileName,
            string serverPath,
            string modelPath,
            InfoUtente userInfo,
            Ruolo role,
            bool isProfilationRequired,
            bool isRapidClassificationRequired,
            string ftpAddress,
            bool isSmistamentoEnabled,
            String ftpUsername,
            String ftpPassword,
            bool isEnabledPregressi)
        {
            // Il path completo in cui è posizionato il file excel contenente i dati
            // sui documenti da importare
            string completePath = String.Empty;

            // Il risultato dell'elaborazione
            ResultsContainer result = new ResultsContainer();

            try
            {
                // 1. Creazione del file temporaneo in cui poggiare il foglio
                // excel contenente i dati sui documenti da importare
                completePath = ImportUtils.CreateTemporaryFile(content, modelPath, fileName);

                // 2. Creazione dei documenti
                result = CreateDocuments(completePath, userInfo, role, serverPath, isProfilationRequired, isRapidClassificationRequired, ftpAddress, isSmistamentoEnabled, ftpUsername, ftpPassword, isEnabledPregressi);
                // 3. Cancellazione file temporaneo
                ImportUtils.DeleteTemporaryFile(completePath);
            }
            catch (Exception e)
            {
                // Se il file è stato creato, cancellazione
                if (!String.IsNullOrEmpty(completePath))
                {
                    ImportUtils.DeleteTemporaryFile(completePath);
                }

                // Creazione di un nuovo risultato con i dettagli dell'eccezione
                result.General.Add(new ImportResult()
                {
                    Outcome = ImportResult.OutcomeEnumeration.KO,
                    Message = e.Message
                });
            }

            // 4. Restituzione del risultato
            return(result);
        }
Exemple #2
0
        /// <summary>
        /// Funzione per l'estrazione dei dati sui documenti RDE
        /// da importare leggendo i dati da foglio Excel
        /// </summary>
        /// <param name="modelRootPath">Il path in cui andare a salvare il file temporaneo</param>
        /// <param name="provider">Il provider dati da utilizzare per la connessione al file Excel</param>
        /// <param name="extendedProperties">Le proprietà estese da utilizzare per la connessione al file Excel</param>
        /// <param name="fileName">Il nome da attribuire al file temporaneo</param>
        /// <param name="content">Il contenuto del file</param>
        /// <param name="versionNumber">Il numero di versione dell'importer da utilizzare:
        ///     - 1 per la versione che non contempla i protocolli interni ed i corrispondenti identificati tramite codice
        ///     - 2 per la versione che contempla i protocolli interni ed i corrispondenti identificati tramite codice</param>
        /// <returns>Il contenitore dei dati estratti dal foglio</returns>
        public static DocumentRowDataContainer ReadDataFromExcel(
            string modelRootPath,
            string provider,
            string extendedProperties,
            string fileName,
            byte[] content,
            int versionNumber)
        {
            // Il path in cui è stato creato il file temportaneo
            string completePath;

            // L'oggetto da restituire
            DocumentRowDataContainer toReturn;

            // 1. Creazione del file temporaneo in cui poggiare il foglio
            // excel contenente i dati sui documenti da importare
            completePath = ImportUtils.CreateTemporaryFile(content, modelRootPath, fileName);

            // 2. Lettura metadati
            try
            {
                toReturn = ReadDataFromExcel(
                    provider,
                    extendedProperties,
                    completePath,
                    versionNumber);
            }
            catch (Exception e)
            {
                throw e;
            }
            finally
            {
                // 3. Cancellazione file temporaneo
                ImportUtils.DeleteTemporaryFile(completePath);
            }

            // Restituzione del risultato
            return(toReturn);
        }
Exemple #3
0
        public static List <ImportResult> ImportElencoNote(byte[] content, string fileName, string modelPath, DocsPaVO.utente.InfoUtente userInfo)
        {
            // Il path completo in cui è posizionato il file excel contente le note da importare
            string completePath = String.Empty;

            // Il risultato dell'elaborazione
            List <ImportResult> result = new List <ImportResult>();

            try
            {
                // 1. Creazione del file temporaneo
                fileName     = fileName.Substring(fileName.LastIndexOf("\\") + 1);
                completePath = ImportUtils.CreateTemporaryFile(content, modelPath, fileName);

                // 2. Creazione delle note
                ArrayList listaRF = BusinessLogic.Utenti.RegistriManager.getListaRegistriRfRuolo(userInfo.idCorrGlobali, "1", "");
                result = CreateNote(completePath, listaRF);

                // 3. Cancellazione file temporaneo
                ImportUtils.DeleteTemporaryFile(completePath);
            }
            catch (Exception e)
            {
                // Se il file è stato creato, cancellazione
                if (!String.IsNullOrEmpty(completePath))
                {
                    ImportUtils.DeleteTemporaryFile(completePath);
                }

                // Creazione di un nuovo risultato con i dettagli dell'eccezione
                result.Add(new ImportResult()
                {
                    Outcome = ImportResult.OutcomeEnumeration.KO,
                    Message = e.Message
                });
            }

            // 4. Restituzione del risultato
            return(result);
        }
Exemple #4
0
        /// <summary>
        /// Funzione per l'estrazione di dati da una sorgente dati excel
        /// </summary>
        /// <param name="content">Il contenuto del foglio excel</param>
        /// <param name="modelPath">Il path in cui andare a salvare il file temporaneo</param>
        /// <param name="fileName">Il nome da associare al file temporaneo</param>
        /// <param name="role">Il ruolo con cui è stata lanciata la procedura</param>
        /// <param name="userInfo">Le informazioni sull'utente che ha lanciato la procedura</param>
        /// <returns>Un oggetto con le informazioni estratte dalla cartella excel relativi a tutte le tipologie di documenti</returns>
        public static DocumentRowDataContainer ReadDataFromExcelFile(
            byte[] content,
            string modelPath,
            string fileName,
            InfoUtente userInfo,
            Ruolo role,
            bool isEnabledPregressi,
            bool isStampaUnione,
            String provider,
            String extendedProperty)
        {
            // Il path in cui è stato creato il file temportaneo
            string completePath;

            // L'oggetto da restituire
            DocumentRowDataContainer toReturn;

            // 1. Creazione del file temporaneo in cui poggiare il foglio
            // excel contenente i dati sui documenti da importare
            completePath = ImportUtils.CreateTemporaryFile(content, modelPath, fileName);

            // 2. Lettura metadati
            try
            {
                toReturn = ReadMetadata(completePath, userInfo, role, isEnabledPregressi, isStampaUnione, provider, extendedProperty);
            }
            catch (Exception e)
            {
                throw e;
            }
            finally
            {
                // 3. Cancellazione file temporaneo
                ImportUtils.DeleteTemporaryFile(completePath);
            }

            // Restituzione del risultato
            return(toReturn);
        }
Exemple #5
0
        /// <summary>
        /// Funzione per l'importazione dei documenti RDA
        /// </summary>
        /// <param name="content">Il contenuto del file Excel</param>
        /// <param name="fileName">Il nome da attribuire al file temporaneo</param>
        /// <param name="serverPath">L'indirizzo della WA</param>
        /// <param name="modelPath">Il path in cui sono memorizzati i modelli</param>
        /// <param name="userInfo">Le informazioni sull'utente che ha lanciato la procedura</param>
        /// <param name="role">Il ruolo con cui è stata lanciata la procedura</param>
        /// <param name="isRapidClassificationRequired">True se è richiesta classificazione rapida obbligatoria</param>
        /// <param name="isSmistamentoEnabled">True se è abilitato lo smistamento</param>
        /// <param name="sharedDirectoryPath">Il path della cartella condivisa</param>
        /// <param name="provider">Il provider da utilizzare per la connessione</param>
        /// <param name="extendedProperty">Le proprietà estese da utilizzare per l'instaurazione della connessione con il provider</param>
        /// <param name="versionNumber">Il numero di versione dell'importer da utilizzare.
        ///     - 1 per la versione che non contempla i protocolli interni ed i corrispondenti identificati tramite codice
        ///     - 2 per la versione che contempla i protocolli interni ed i corrispondenti identificati tramite codice</param>
        /// <returns>Il report relativo all'importazione RDE</returns>
        public static ResultsContainer CreateRDA(
            byte[] content,
            string fileName,
            string serverPath,
            string modelPath,
            InfoUtente userInfo,
            Ruolo role,
            bool isRapidClassificationRequired,
            bool isSmistamentoEnabled,
            string ftpAddress,
            string provider,
            string extendedProperty,
            int versionNumber,
            String ftpUsername,
            String ftpPassword,
            bool isEnabledPregressi)
        {
            // Il path completo in cui è posizionato il file excel contenente i dati
            // sui documenti da importare
            string completePath = String.Empty;

            // L'oggetto con le informazioni sui documenti RDE da importare
            DocumentRowDataContainer container = null;

            // Il risultato dell'elaborazione
            ResultsContainer result = new ResultsContainer();

            try
            {
                // 1. Creazione del file temporaneo in cui poggiare il foglio
                // excel contenente i dati sui documenti da importare
                completePath = ImportUtils.CreateTemporaryFile(content, modelPath, fileName);

                // 2. Caricamento dei dati contenuti all'interno della cartella Excel
                container = ReadDataFromExcel(provider, extendedProperty, completePath, versionNumber);

                // 3. Creazione dei documenti
                result = CreateDocuments(container, userInfo, role, serverPath, isRapidClassificationRequired, isSmistamentoEnabled, ftpAddress, ftpUsername, ftpPassword, isEnabledPregressi);

                // 4. Cancellazione file temporaneo
                ImportUtils.DeleteTemporaryFile(completePath);
            }
            catch (Exception e)
            {
                // Se il file è stato creato, cancellazione
                if (!String.IsNullOrEmpty(completePath))
                {
                    ImportUtils.DeleteTemporaryFile(completePath);
                }

                // Creazione di un nuovo risultato con i dettagli dell'eccezione
                result.General.Add(new ImportResult()
                {
                    Outcome = ImportResult.OutcomeEnumeration.KO,
                    Message = e.Message
                });
            }

            // 4. Restituzione del risultato
            return(result);
        }