Beispiel #1
0
        /// <summary>
        /// Implementazione della logica del task di migrazione dati
        /// per tutti i fascicoli di un'amministrazione
        /// </summary>
        /// <param name="infoUtente"></param>
        /// <param name="amministrazione"></param>
        /// <param name="opzioniMigrazione"></param>
        private static void ImportaFascicoli(InfoUtente infoUtente, InfoAmministrazione amministrazione, OpzioniMigrazioneFascicolo opzioniMigrazione)
        {
            InfoStatoMigrazione statoMigrazione = StatoMigrazione.Get(amministrazione);

            try
            {
                using (DocsPaDB.DBProvider dbProvider = new DocsPaDB.DBProvider())
                {
                    // Viene assegnato all'infoutente l'id dell'amministrazione fornita come parametro
                    // per fare in modo che l'utente che esegue la migrazione si impersonifichi
                    // come utente dell'amministrazione
                    string idAmm = infoUtente.idAmministrazione;
                    infoUtente.idAmministrazione = amministrazione.IDAmm;

                    using (DataSet ds = new DataSet())
                    {
                        // 1. Reperimento fascicoli per il titolario
                        if (dbProvider.ExecuteQuery(ds, GetQueryFascicoli(infoUtente, opzioniMigrazione.Filtro)))
                        {
                            Log.GetInstance(amministrazione).Write("Reperimento fascicoli in amministrazione.", false);

                            int index = 1;

                            foreach (DataRow row in ds.Tables[0].Rows)
                            {
                                if (_interrompiMigrazione)
                                {
                                    _interrompiMigrazione = false;
                                    Log.GetInstance(amministrazione).Write(string.Format("Migrazione fascicoli interrotta al fascicolo {0} di {1}", index.ToString(), ds.Tables[0].Rows.Count), false);
                                    break;
                                }

                                // 2. Migrazione dei singoli fascicoli
                                ImportaFascicolo(row, infoUtente, amministrazione, statoMigrazione);

                                index++;
                            }
                        }
                        else
                        {
                            // 1a. Errore nel reperimento dei fascicoli
                            throw new ApplicationException(
                                      string.Format("Si è verificato un errore nel reperimento dei fascicolo per l'amministrazione '{0}'",
                                                    amministrazione.Codice));
                        }
                    }

                    infoUtente.idAmministrazione = idAmm;
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                // Save dello stato migrazione
                StatoMigrazione.Save(statoMigrazione, amministrazione);
            }
        }
Beispiel #2
0
        /// <summary>
        /// Salva metadati di migrazione
        /// </summary>
        /// <param name="stato"></param>
        /// <param name="amministrazione"></param>
        public static void Save(InfoStatoMigrazione stato, DocsPaVO.amministrazione.InfoAmministrazione amministrazione)
        {
            string filePath = AppDataFolder.GetStatoMigrazioneFilePath(amministrazione);

            using (FileStream stream = new FileStream(filePath, FileMode.Create, FileAccess.Write, FileShare.Write))
            {
                XmlSerializer serializer = new XmlSerializer(typeof(InfoStatoMigrazione));

                serializer.Serialize(stream, stato);
            }
        }
Beispiel #3
0
        /// <summary>
        /// Aggiornamento di un'amministrazione
        /// </summary>
        /// <param name="infoUtente"></param>
        /// <param name="amministrazione"></param>
        /// <param name="tipiOggetti"></param>
        /// <returns></returns>
        internal static void AggiornaAmministrazione(InfoUtenteAmministratore infoUtente, DocsPaVO.amministrazione.InfoAmministrazione amministrazione, TipiOggettiAmministrazione tipiOggetti)
        {
            InfoStatoMigrazione statoMigrazione = StatoMigrazione.Get(amministrazione);

            AmministrazioneManager amministraManager = new AmministrazioneManager(infoUtente);

            // 1. Verifica amministrazione esistente in DCTM
            if (amministraManager.ContainsAmministrazione(amministrazione.Codice))
            {
                List <string> ruoliImportati = null;

                try
                {
                    // 2. Creazione delle utenze dell'amministrazione
                    if (tipiOggetti.Organigramma)
                    {
                        Organigramma.ImportaUtenti(infoUtente, amministrazione);

                        // 3. Creazione dei ruoli dell'amministrazione
                        Organigramma.ImportaRuoli(infoUtente, amministrazione, out ruoliImportati);

                        // 4. Associazione degli utenti ai ruoli dell'amministrazione
                        Organigramma.ImportaAssociazioniUtentiRuoli(infoUtente, amministrazione);
                    }

                    if (tipiOggetti.Titolario)
                    {
                        // 5. Creazione dei titolari dell'amministrazione
                        Titolario.ImportaTitolari(infoUtente, amministrazione);
                    }

                    // Imposta lo stato dell'amministrazione come migrata correttamente
                    statoMigrazione.DatiAmministrazioneMigrati = true;

                    // Salva stato della migrazione
                    StatoMigrazione.Save(statoMigrazione, amministrazione);
                }
                catch (Exception ex)
                {
                    // Rollback: in caso di errore, viene rimossa l'amministrazione appena inserita
                    // per mantenere i dati consistenti
                    Log.GetInstance(amministrazione).Write(string.Format("Si è verificato un errore nella procedura di migrazione l'amministrazione '{0}'.", amministrazione.Codice), false);

                    throw ex;
                }
            }
            else
            {
                // 1a. Errore nella migrazione dell'amministrazione (migrazione interrotta)
                throw new ApplicationException(string.Format("Si è verificato un errore nell'aggiornamento dell'amministrazione. Amministrazione con codice {0} non esistente", amministrazione.Codice));
            }
        }
Beispiel #4
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="infoUtente"></param>
        /// <param name="amministrazione"></param>
        /// <param name="fascicoli"></param>
        private static void ImportaFascicoliSelezionati(InfoUtente infoUtente, DocsPaVO.amministrazione.InfoAmministrazione amministrazione, Migrazione.InfoFascicoloMigrazione[] fascicoli)
        {
            InfoStatoMigrazione statoMigrazione = StatoMigrazione.Get(amministrazione);

            try
            {
                // Viene assegnato all'infoutente l'id dell'amministrazione fornita come parametro
                // per fare in modo che l'utente che esegue la migrazione si impersonifichi
                // come utente dell'amministrazione
                string idAmm = infoUtente.idAmministrazione;
                infoUtente.idAmministrazione = amministrazione.IDAmm;

                int index = 1;

                foreach (Migrazione.InfoFascicoloMigrazione infoFascicolo in fascicoli)
                {
                    if (_interrompiMigrazione)
                    {
                        _interrompiMigrazione = false;
                        Log.GetInstance(amministrazione).Write(string.Format("Migrazione fascicoli interrotta al fascicolo {0} di {1}", index.ToString(), fascicoli.Length), false);
                        break;
                    }

                    // 1. Reperimento oggetto fascicolo
                    infoUtente.idGruppo = DocsPaDocumentale_DOCUMENTUM.DocsPaServices.DocsPaQueryHelper.getRuoloCreatore(infoFascicolo.Id).idGruppo;
                    DocsPaVO.fascicolazione.Fascicolo fascicolo = GetFascicolo(infoFascicolo.Id, infoUtente);

                    // 2. Migrazione dei singoli fascicoli
                    ImportaFascicolo(fascicolo, infoUtente, amministrazione, statoMigrazione);

                    index++;
                }

                infoUtente.idAmministrazione = idAmm;
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                // Save dello stato migrazione
                StatoMigrazione.Save(statoMigrazione, amministrazione);
            }
        }
Beispiel #5
0
        /// <summary>
        /// Reperimento metadati di migrazione
        /// </summary>
        /// <param name="amministrazione"></param>
        /// <returns></returns>
        public static InfoStatoMigrazione Get(DocsPaVO.amministrazione.InfoAmministrazione amministrazione)
        {
            InfoStatoMigrazione retValue = null;

            string filePath = AppDataFolder.GetStatoMigrazioneFilePath(amministrazione);

            if (File.Exists(filePath))
            {
                using (FileStream stream = new FileStream(filePath, FileMode.Open, FileAccess.Read, FileShare.Read))
                {
                    XmlSerializer serializer = new XmlSerializer(typeof(InfoStatoMigrazione));

                    retValue = (InfoStatoMigrazione)serializer.Deserialize(stream);
                }
            }

            if (retValue == null)
            {
                retValue = new InfoStatoMigrazione(amministrazione.IDAmm, amministrazione.Codice);
            }

            return(retValue);
        }
Beispiel #6
0
        /// <summary>
        /// Implementazione della logica del task di migrazione dati
        /// per una singola amministrazione DocsPa
        /// </summary>
        /// <param name="infoUtente"></param>
        /// <param name="amministrazione"></param>
        private static void ImportaAmministrazione(InfoUtenteAmministratore infoUtente, InfoAmministrazione amministrazione)
        {
            InfoStatoMigrazione statoMigrazione = StatoMigrazione.Get(amministrazione);

            AmministrazioneManager amministraManager = new AmministrazioneManager(infoUtente);

            // 1. Creazione dell'amministrazione in DCTM
            EsitoOperazione result = amministraManager.Insert(amministrazione);

            if (result.Codice == RESULT_CODE_OK)
            {
                Log.GetInstance(amministrazione).Write(string.Format("Creata amministrazione con codice '{0}'", amministrazione.Codice), false);

                List <string> ruoliImportati = null;

                try
                {
                    // 2. Creazione delle utenze dell'amministrazione
                    Organigramma.ImportaUtenti(infoUtente, amministrazione);

                    // 3. Creazione dei ruoli dell'amministrazione
                    Organigramma.ImportaRuoli(infoUtente, amministrazione, out ruoliImportati);

                    // 4. Associazione degli utenti ai ruoli dell'amministrazione
                    Organigramma.ImportaAssociazioniUtentiRuoli(infoUtente, amministrazione);

                    // 5. Creazione dei titolari dell'amministrazione
                    Titolario.ImportaTitolari(infoUtente, amministrazione);

                    // Imposta lo stato dell'amministrazione come migrata correttamente
                    statoMigrazione.DatiAmministrazioneMigrati = true;

                    // Salva stato della migrazione
                    StatoMigrazione.Save(statoMigrazione, amministrazione);
                }
                catch (Exception ex)
                {
                    // Rollback: in caso di errore, viene rimossa l'amministrazione appena inserita
                    // per mantenere i dati consistenti
                    EsitoOperazione rollback = null;

                    /* Deletami sto cazzo figlio di Troia ...
                     * if (ruoliImportati != null)
                     *  rollback = amministraManager.Delete(amministrazione, ruoliImportati.ToArray());
                     * else
                     *  rollback = amministraManager.Delete(amministrazione); */


                    // if (rollback.Codice != RESULT_CODE_OK)
                    //   Log.GetInstance(amministrazione).Write(string.Format("Errore nel Rollback: {0}", rollback.Descrizione), false);
                    //else
                    Log.GetInstance(amministrazione).Write(string.Format("Si è verificato un errore nella procedura di migrazione l'amministrazione '{0}'. Le operazioni finora effettuate sono state annullate.", amministrazione.Codice), false);

                    throw ex;
                }
            }
            else
            {
                // 1a. Errore nella migrazione dell'amministrazione (migrazione interrotta)
                throw new ApplicationException(string.Format("Si è verificato un errore nell'inserimento dell'amministrazione. Codice: {0} - Descrizione: {1}", result.Codice, result.Descrizione));
            }
        }
Beispiel #7
0
        /// <summary>
        /// Import dei sottofascicoli per un fascicolo
        /// </summary>
        /// <param name="infoUtente"></param>
        /// <param name="amministrazione"></param>
        /// <param name="fascicolo"></param>
        /// <param name="ruolo"></param>
        /// <param name="statoMigrazione"></param>
        /// <param name="folders"></param>
        private static void ImportaSottofascicoli(InfoUtente infoUtente, InfoAmministrazione amministrazione, DocsPaVO.fascicolazione.Fascicolo fascicolo, DocsPaVO.fascicolazione.Folder[] folders, DocsPaVO.utente.Ruolo ruolo, InfoStatoMigrazione statoMigrazione)
        {
            DocsPaDocumentale_DOCUMENTUM.Documentale.ProjectManager projectManager = new DocsPaDocumentale_DOCUMENTUM.Documentale.ProjectManager(infoUtente);

            // Fascicolo precedentementei importato
            DocsPaVO.fascicolazione.Folder previousFolder = null;
            int countRenamed = 0;

            if (folders == null)
            {
                folders = GetFolders(infoUtente, fascicolo);
            }

            // 1. Reperimento sottofascicoli contenuti nel fascicolo
            foreach (DocsPaVO.fascicolazione.Folder folder in folders)
            {
                if (projectManager.ContainsSottofascicolo(folder.systemID))
                {
                    // Inserimento dei metadati di migrazione per il folder
                    InfoFascicoloMigrazione infoFascicolo = new InfoFascicoloMigrazione(fascicolo, folder);

                    // Sottofascicolo è già esistente, save dei dati
                    infoFascicolo.EsitoMigrazione = projectManager.ModifyFolder(folder);

                    if (!infoFascicolo.EsitoMigrazione)
                    {
                        infoFascicolo.ErroreMigrazione = string.Format("Errore nella modifica del sottofascicolo: '{0}'", folder.descrizione);
                    }

                    statoMigrazione.SetFascicoloMigrazione(infoFascicolo);

                    if (folder.childs.Count > 0)
                    {
                        // Import dei sottofascicoli figli
                        ImportaSottofascicoli(infoUtente, amministrazione, fascicolo,
                                              (DocsPaVO.fascicolazione.Folder[])folder.childs.ToArray(typeof(DocsPaVO.fascicolazione.Folder)),
                                              ruolo, statoMigrazione);
                    }

                    // Sottofascicolo già esistente
                    Log.GetInstance(amministrazione).Write(string.Format("Sottofascicolo con codice {0} già esistente. Aggiornamento.", folder.descrizione), false);
                }
                else
                {
                    // Il sottofascicolo non ha descrizione, viene impostata la system_id
                    if (string.IsNullOrEmpty(folder.descrizione))
                    {
                        folder.descrizione = folder.systemID;
                    }

                    string oldDescription = folder.descrizione;

                    // Verifica se, nell'ambito dello stesso fascicolo, esistono sottofascicoli con descrizione duplicata
                    // if (DocsPaDocumentale_DOCUMENTUM.DctmServices.Dfs4DocsPa.containsSottofascicoloByDescription(folder.idFascicolo, folder.descrizione))
                    // {
                    folder.descrizione = string.Format("{0} ({1})", folder.descrizione, folder.systemID);

                    // Log.GetInstance(amministrazione).Write(string.Format("Migrazione sottofascicolo. Rinominato sottofascicolo duplicato '{0}' in '{1}'", oldDescription, folder.descrizione), false);
                    // }

                    DocsPaVO.fascicolazione.ResultCreazioneFolder resultCreazioneFolder;

                    // 3. Creazione oggetto Folder
                    if (projectManager.CreateFolder(folder, ruolo, out resultCreazioneFolder))
                    {
                        // Inserimento dei metadati di migrazione per il folder
                        InfoFascicoloMigrazione infoFascicolo = new InfoFascicoloMigrazione(fascicolo, folder);
                        infoFascicolo.EsitoMigrazione = true;
                        statoMigrazione.SetFascicoloMigrazione(infoFascicolo);

                        Log.GetInstance(amministrazione).Write(string.Format("Migrazione sottofascicolo. Descrizione sottofascicolo: '{0}' - Codice: '{1}' - Descrizione: '{2}'", folder.descrizione, fascicolo.codice, fascicolo.descrizione), false);

                        folder.descrizione = oldDescription;
                        previousFolder     = folder;

                        if (folder.childs.Count > 0)
                        {
                            // Import dei sottofascicoli figli
                            ImportaSottofascicoli(infoUtente, amministrazione, fascicolo,
                                                  (DocsPaVO.fascicolazione.Folder[])folder.childs.ToArray(typeof(DocsPaVO.fascicolazione.Folder)),
                                                  ruolo, statoMigrazione);
                        }
                    }
                    else
                    {
                        // 2a. Errore nell'inserimento del folder
                        throw new ApplicationException(
                                  string.Format("Si è verificato un errore nell'inserimento del sottofascicolo '{0}' per il fascicolo '{1}' per l'amministrazione '{2}'",
                                                folder.descrizione, fascicolo.codice, amministrazione.Codice));
                    }
                }
            }
        }
Beispiel #8
0
        /// <summary>
        /// Migrazione di un singolo fascicolo
        /// </summary>
        /// <param name="row"></param>
        /// <param name="infoUtente"></param>
        /// <param name="amministrazione"></param>
        /// <param name="statoMigrazione"></param>
        private static void ImportaFascicolo(DataRow row, InfoUtente infoUtente, InfoAmministrazione amministrazione, InfoStatoMigrazione statoMigrazione)
        {
            // 1. Reperimento oggetto fascicolo
            DocsPaVO.fascicolazione.Fascicolo fascicolo = GetFascicolo(row, infoUtente);

            // 2. Migrazione fascicolo
            ImportaFascicolo(fascicolo, infoUtente, amministrazione, statoMigrazione);
        }
Beispiel #9
0
        /// <summary>
        /// Migrazione di un singolo fascicolo
        /// </summary>
        /// <param name="fascicolo"></param>
        /// <param name="infoUtente"></param>
        /// <param name="amministrazione"></param>
        /// <param name="statoMigrazione"></param>
        private static void ImportaFascicolo(DocsPaVO.fascicolazione.Fascicolo fascicolo, InfoUtente infoUtente, InfoAmministrazione amministrazione, InfoStatoMigrazione statoMigrazione)
        {
            DocsPaDocumentale_DOCUMENTUM.Documentale.ProjectManager projectManager   = new DocsPaDocumentale_DOCUMENTUM.Documentale.ProjectManager(infoUtente);
            DocsPaDocumentale.Interfaces.IAclEventListener          aclEventListener = new DocsPaDocumentale_DOCUMENTUM.Documentale.AclEventListener(infoUtente);

            // 1. Reperimento del ruolo creatore del fascicolo
            DocsPaVO.utente.Ruolo ruolo = DocsPaDocumentale_DOCUMENTUM.DocsPaServices.DocsPaQueryHelper.getRuoloCreatore(fascicolo.systemID);

            // NB: il reperimento dei fascicoli generali serve solo per migrare
            // gli eventuali sottofascicoli, non per migrare il fascicolo stesso,
            // che è già stato creato in sede di creazione del nodo di titolario
            if (fascicolo.tipo == "G")
            {
                // 2. Migrazione dei sottofascicoli, in caso di fascicolo generale (già creato in sede di creazione del titolario)
                ImportaSottofascicoli(infoUtente, amministrazione, fascicolo, null, ruolo, statoMigrazione);
            }
            else
            {
                InfoFascicoloMigrazione fascicoloMigrazione = new InfoFascicoloMigrazione(fascicolo);

                // Calcolo dell'hash del fascicolo
                fascicoloMigrazione.HashFascicolo = GetHashFascicolo(fascicolo, true);

                // 2. Creazione del corrispondente fascicolo in documentum
                DocsPaVO.fascicolazione.ResultCreazioneFascicolo result;
                DocsPaVO.utente.Ruolo[] ruoliSuperiori;

                if (projectManager.ContainsFascicoloProcedimentale(fascicolo.systemID))
                {
                    // Fascicolo è già esistente, save dei dati con refresh delle entries dell'acl associata
                    fascicoloMigrazione.EsitoMigrazione = projectManager.ModifyProject(fascicolo, true);

                    if (!fascicoloMigrazione.EsitoMigrazione)
                    {
                        fascicoloMigrazione.ErroreMigrazione = string.Format("Si è verificato un errore nella modifica del fascicolo '{0}' per l'amministrazione '{1}'", fascicolo.codice, amministrazione.Codice);
                    }
                    else
                    {
                        // Migrazione dei sottofascicoli
                        ImportaSottofascicoli(infoUtente, amministrazione, fascicolo, null, ruolo, statoMigrazione);
                    }

                    Log.GetInstance(amministrazione).Write(string.Format("Migrazione fascicolo. Codice: '{0}' - Descrizione: '{1}'. Aggiornamento.", fascicolo.codice, fascicolo.descrizione), false);
                }
                else if (projectManager.CreateProject(null,
                                                      fascicolo,
                                                      ruolo,
                                                      false,
                                                      out result,
                                                      out ruoliSuperiori))
                {
                    if (result == DocsPaVO.fascicolazione.ResultCreazioneFascicolo.OK)
                    {
                        fascicoloMigrazione.EsitoMigrazione = true;

                        Log.GetInstance(amministrazione).Write(string.Format("Migrazione fascicolo. Codice: '{0}' - Descrizione: '{1}'", fascicolo.codice, fascicolo.descrizione), false);

                        // 3. Notifica evento di creazione fascicolo completato
                        aclEventListener.FascicoloCreatoEventHandler(null, fascicolo, ruolo, ruoliSuperiori);

                        try
                        {
                            // 4. Migrazione dei sottofascicoli
                            ImportaSottofascicoli(infoUtente, amministrazione, fascicolo, null, ruolo, statoMigrazione);
                        }
                        catch (Exception ex)
                        {
                            //4a. Errore nella migrazione dei sottofascicoli, viene rimosso il fascicolo creato
                            ((DocsPaDocumentale_DOCUMENTUM.Documentale.ProjectManager)projectManager).DeleteProject(fascicolo);

                            fascicoloMigrazione.EsitoMigrazione  = false;
                            fascicoloMigrazione.ErroreMigrazione = ex.Message;
                        }

                        // 5. Impostazione ownership del fascicolo
                        string utenteCreatore = DocsPaDocumentale_DOCUMENTUM.DocsPaObjectTypes.TypeUtente.NormalizeUserName(DocsPaDocumentale_DOCUMENTUM.DocsPaServices.DocsPaQueryHelper.getUtenteCreatore(fascicolo.systemID).userId);
                        ((DocsPaDocumentale_DOCUMENTUM.Documentale.ProjectManager)projectManager).SetOwnershipFascicolo(fascicolo.systemID, utenteCreatore);
                    }
                    else
                    {
                        // 3a. Errore nella creazione del fascicolo
                        fascicoloMigrazione.EsitoMigrazione  = false;
                        fascicoloMigrazione.ErroreMigrazione = string.Format("Si è verificato un errore nella creazione del fascicolo '{0}' per l'amministrazione '{1}'", fascicolo.codice, amministrazione.Codice);
                    }
                }

                fascicoloMigrazione.DataMigrazione = DateTime.Now.ToString();
                statoMigrazione.SetFascicoloMigrazione(fascicoloMigrazione);
            }
        }