/// <summary> /// Creazione oggetto amministrazione /// </summary> /// <param name="reader"></param> /// <returns></returns> private static InfoAmministrazione GetInfoAmministrazione(IDataReader reader) { InfoAmministrazione amm = new InfoAmministrazione(); amm.Codice = DataReaderHelper.GetValue <string>(reader, "CODICE", false); logger.Debug("codice amministrazioni trovata: " + amm.Codice); amm.IDAmm = DataReaderHelper.GetValue <string>(reader, "ID", false); logger.Debug("ID amministrazioni trovata: " + amm.IDAmm); amm.Descrizione = DataReaderHelper.GetValue <string>(reader, "DESCR", false); amm.LibreriaDB = DataReaderHelper.GetValue <string>(reader, "LIBRERIA", true, string.Empty); amm.Segnatura = DataReaderHelper.GetValue <string>(reader, "SEGN", true, string.Empty); amm.Fascicolatura = DataReaderHelper.GetValue <string>(reader, "FASC", true, string.Empty); amm.Dominio = DataReaderHelper.GetValue <string>(reader, "DOMINIO", true, string.Empty); amm.ServerSMTP = DataReaderHelper.GetValue <string>(reader, "SMTP", true, string.Empty); amm.PortaSMTP = DataReaderHelper.GetValue <string>(reader, "PORTASMTP", true, string.Empty); amm.UserSMTP = DataReaderHelper.GetValue <string>(reader, "USERSMTP", true, string.Empty); amm.PasswordSMTP = DataReaderHelper.GetValue <string>(reader, "PWDSMTP", true, string.Empty); amm.IDRagioneTO = DataReaderHelper.GetValue <string>(reader, "RAGTO", true, string.Empty); //DocsPaUtils.LogsManagement.Debugger.Write("amministrazioni trovata IDRagioneTO: " + amm.IDRagioneTO); amm.IDRagioneCC = DataReaderHelper.GetValue <string>(reader, "RAGCC", true, string.Empty); amm.GGPermanenzaTDL = DataReaderHelper.GetValue <string>(reader, "GG_TDL", true, string.Empty); amm.AttivaGGPermanenzaTDL = DataReaderHelper.GetValue <string>(reader, "A_GG_TDL", true, string.Empty); amm.SslSMTP = DataReaderHelper.GetValue <string>(reader, "SMTP_SSL", true, string.Empty); amm.StaSMTP = DataReaderHelper.GetValue <string>(reader, "SMTP_STA", true, string.Empty); amm.FromEmail = DataReaderHelper.GetValue <string>(reader, "FROM_EMAIL", true, string.Empty); amm.IDRagioneCompetenza = DataReaderHelper.GetValue <object>(reader, "RAGCOMP", true, string.Empty).ToString(); amm.IDRagioneConoscenza = DataReaderHelper.GetValue <string>(reader, "RAGCONO", true, string.Empty); return(amm); }
/// <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); } }
/// <summary> /// Cancellazione di un'amministrazione nel documentale ocs /// </summary> /// <param name="info"></param> /// <param name="adminRoles"> /// Ruoli docspa creati e da rimuovere in ocs /// </param> /// <returns></returns> public EsitoOperazione Delete(InfoAmministrazione info, DocsPaVO.amministrazione.OrgRuolo[] adminRoles) { EsitoOperazione retValue = new EsitoOperazione(); try { //// Prima della cancellazione in etdocs, è necessario //// reperire i gruppi docspa e passarli successivamente a OCS //OrgRuolo[] docspaGroups = this.GetGroups(info.IDAmm); IOrganigrammaManager orgMng = new OrganigrammaManager(this.InfoUtente); foreach (OrgRuolo role in adminRoles) { retValue = orgMng.EliminaRuolo(role); if (retValue.Codice != 0) { break; } } } catch (Exception ex) { logger.Error(string.Format("Errore in OCS.DeleteAmministrazione:\n{0}", ex.ToString())); retValue.Codice = -1; retValue.Descrizione = string.Format("Errore nella rimozione in OCS", info.Codice); } return(retValue); }
/// <summary> /// Creazione ACL per l'amministrazione /// </summary> /// <param name="info"></param> /// <returns></returns> protected virtual CustomServices.AclDefinition CreateAclAdmin(InfoAmministrazione info) { CustomServices.AclDefinition aclData = null; try { // Reperimento ACL per gli oggetti visibili da tutta l'amministrazione aclData = Dfs4DocsPa.getAclDefinitionAmministrazione(info.Codice); CustomServices.IAclService aclService = DctmServiceFactory.GetCustomServiceInstance <CustomServices.IAclService>(UserManager.ImpersonateSuperUser()); CustomServices.ObjectIdentity aclIdentity = aclService.Create(aclData); if (aclIdentity == null) { throw new ApplicationException(string.Concat("Errore nella creazione dell'ACL per l'amministrazione con ID '{0}'", info.IDAmm)); } } catch (Exception ex) { string errorMessage = string.Format("Errore in Documentum.CreateAclAdmin:\n{0}", ex.ToString()); logger.Debug(errorMessage); throw new ApplicationException(errorMessage); } return(aclData); }
/// <summary> /// Cancellazione di un'amministrazione nel documentale /// </summary> /// <param name="info"></param> /// <returns></returns> public EsitoOperazione Delete(InfoAmministrazione info) { EsitoOperazione esito = new EsitoOperazione(); DocsPaDB.Query_DocsPAWS.Amministrazione dbAmm = new DocsPaDB.Query_DocsPAWS.Amministrazione(); // verifica se ci sono doc creati da utenti dell'amm.ne if (dbAmm.AmmContainsDocumenti(info.IDAmm)) { esito.Codice = 1; esito.Descrizione = "impossibile eliminare questa amministrazione: trovati documenti creati da utenti di questa amministrazione"; } else { string outMsg; if (!dbAmm.DeleteAmministrazione(info, out outMsg)) { if (outMsg != "") { esito.Codice = 2; esito.Descrizione = "si è verificato un errore mentre venivano eliminati record sulla tabella:\\n" + outMsg; } else { esito.Codice = 3; esito.Descrizione = "si è verificato un errore durante la procedura di eliminazione dell'amministrazione"; } } } return(esito); }
/// <summary> /// Reperimento query titolario /// </summary> /// <param name="infoUtente"></param> /// <param name="amministrazione"></param> /// <returns></returns> private static string GetQueryTitolari(InfoUtente infoUtente, InfoAmministrazione amministrazione) { return (string.Format( "SELECT DISTINCT " + "a.system_id as IDRECORD, " + "a.var_codice as CODICE, " + "a.description as DESCRIZIONE, " + "a.num_livello as LIVELLO, " + "a.id_registro as REGISTRO, " + "a.id_parent as IDPARENT, " + "a.var_cod_liv1 as CODLIV, " + "cha_rw as RW, " + "(SELECT count(b.system_id) " + "FROM PROJECT b " + "WHERE b.cha_tipo_proj = 'T' " + "AND b.id_amm = 1 " + "AND b.id_parent = a.system_id " + ") as FIGLIO, " + "a.NUM_MESI_CONSERVAZIONE as NUMMESICONSERVAZIONE, " + "a.ID_TIPO_FASC, " + "a.CHA_BLOCCA_FASC, " + "a.ID_TITOLARIO, " + "a.CHA_STATO, " + "a.DTA_ATTIVAZIONE, " + "a.DTA_CESSAZIONE, " + "a.VAR_NOTE " + "FROM PROJECT a "+ "WHERE a.cha_tipo_proj = 'T' "+ "AND a.id_amm = {0} " + "ORDER BY a.var_cod_liv1 ", amministrazione.IDAmm)); }
/// <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); }
public static DocsPaConservazione.Metadata.Common.Amministrazione getInfoAmministrazione(InfoConservazione infoCons) { InfoAmministrazione infoAmm = BusinessLogic.Amministrazione.AmministraManager.AmmGetInfoAmmCorrente(infoCons.IdAmm); return(new Metadata.Common.Amministrazione { CodiceAmministrazione = infoAmm.Codice, DescrizioneAmministrazione = infoAmm.Descrizione }); }
/// <summary> /// Inserimento di una nuova amministrazione nel documentale /// </summary> /// <param name="info"></param> /// <returns></returns> public EsitoOperazione Insert(InfoAmministrazione info) { EsitoOperazione retValue = this.InstanceETDOCS.Insert(info); return(retValue); }
/// <summary> /// Cancellazione di un'amministrazione nel documentale /// </summary> /// <param name="info"></param> /// <returns></returns> public EsitoOperazione Delete(InfoAmministrazione info) { // Prima della cancellazione in etdocs, è necessario // reperire i gruppi docspa e passarli successivamente a documentum string[] docspaGroups = this.GetGroupNames(info.IDAmm); EsitoOperazione retValue = this.InstanceETDOCS.Delete(info); return(retValue); }
/// <summary> /// Rimozione delle ACL per tutti gli oggetti dell'amministrazione /// </summary> /// <param name="info"></param> protected virtual void DeleteAcl(InfoAmministrazione info) { // Creazione servizio ACL (con credenziali da superamministratore) CustomServices.IAclService aclService = DctmServiceFactory.GetCustomServiceInstance <CustomServices.IAclService>(UserManager.ImpersonateSuperUser()); // Rimozione di tutte le ACL di tutti gli oggetti dell'amministrazione // NB: Il parametro force + per ogni evenienza, ma sarebbe da evitarne l'uso: può creare inconsistenze nel DB di Documentum int affectedRows = aclService.DeleteAll(DctmConfigurations.GetRepositoryName(), AclHelper.getAclName(info.Codice), true); logger.Debug(string.Format("Rimozione ACL per tutti gli oggetti dell'amministrazione. Rimossi {0} oggetti", affectedRows.ToString())); }
/// <summary> /// Inserimento di una nuova amministrazione nel documentale /// </summary> /// <param name="info"></param> /// <returns></returns> public EsitoOperazione Insert(InfoAmministrazione info) { EsitoOperazione retValue = this.InstanceETDOCS.Insert(info); if (retValue.Codice == 0) { retValue = this.InstanceDCTM.Insert(info); } return(retValue); }
/// <summary> /// Inserimento di una nuova amministrazione nel documentale /// </summary> /// <param name="info"></param> /// <returns></returns> public EsitoOperazione Insert(InfoAmministrazione info) { EsitoOperazione retValue = this.InstanceETDOCS.Insert(info); // ?? al momento non sembra necessario creare qualcosa relativo ad un'amministrazione su OCS //if (retValue.Codice == 0) //{ // retValue = this.InstanceOCS.Insert(info); //} return(retValue); }
/// <summary> /// Implementazione della logica del task di migrazione dati /// per tutti i ruoli di una singola amministrazione DocsPa /// </summary> /// <param name="infoUtente"></param> /// <param name="amministrazione"></param> public static void ImportaRuoli(InfoUtente infoUtente, InfoAmministrazione amministrazione, out List <string> ruoliImportati) { ruoliImportati = new List <string>(); // 1. Reperimento ruoli dell'amministrazione OrgRuolo[] roles = GetRuoli(infoUtente, amministrazione); if (roles.Length > 0) { Log.GetInstance(amministrazione).Write(string.Format("Reperimento dei ruoli dell'amministrazione. Numero ruoli: {0}", roles.Length.ToString()), false); // 2. Import di ciascun ruolo in DCTM /* * DocsPaDocumentale_DOCUMENTUM.Documentale.OrganigrammaManager organigrammaManager = new DocsPaDocumentale_DOCUMENTUM.Documentale.OrganigrammaManager(infoUtente); * * foreach (OrgRuolo role in roles) * { * // 3. Verifica esistenza ruolo * if (organigrammaManager.ContainsGroup(role.Codice)) * { * Log.GetInstance(amministrazione).Write(string.Format("Ruolo '{0}' già esistente", role.Codice), false); * } * else * { * EsitoOperazione result = organigrammaManager.InserisciRuolo(role, false); * * if (result.Codice == RESULT_CODE_OK) * { * Log.GetInstance(amministrazione).Write(string.Format("Migrazione ruolo '{0}'", role.Codice), false); * * ruoliImportati.Add(role.Codice); * } * else * { * // 2a. Errore nell'import del ruolo (migrazione interrotta) * throw new ApplicationException( * string.Format("Si è verificato un errore nell'import del ruolo '{0}' per l'amministrazione '{1}'. Codice: {2} - Descrizione: {3}", * role.Codice, amministrazione.Codice, result.Codice.ToString(), result.Descrizione) * ); * } * } * }*/ } else { // 1a. Errore nella migrazione dei ruoli (migrazione interrotta) throw new ApplicationException( string.Format("Si è verificato un errore nell'import dei ruoli per l'amministrazione '{0}'. Descrizione: Nessun ruolo trovato", amministrazione.Codice)); } }
/// <summary> /// Cancellazione di un'amministrazione nel documentale /// </summary> /// <param name="info"></param> /// <returns></returns> public EsitoOperazione Delete(InfoAmministrazione info) { // Prima della cancellazione in etdocs, è necessario // reperire i gruppi docspa e passarli successivamente a documentum string[] docspaGroups = this.GetGroupNames(info.IDAmm); EsitoOperazione retValue = this.InstanceETDOCS.Delete(info); if (retValue.Codice == 0) { retValue = ((DocsPaDocumentale_DOCUMENTUM.Documentale.AmministrazioneManager) this.InstanceDCTM).Delete(info, docspaGroups); } return(retValue); }
/// <summary> /// Cancellazione di un'amministrazione nel documentale /// </summary> /// <param name="info"></param> /// <returns></returns> public EsitoOperazione Delete(InfoAmministrazione info) { // Prima della cancellazione in etdocs, è necessario // reperire i gruppi docspa e passarli successivamente a OCS DocsPaVO.amministrazione.OrgRuolo[] adminRoles = DocsPaDocumentale_OCS.DocsPaServices.DocsPaQueryHelper.getAdminGroups(info.IDAmm); EsitoOperazione retValue = this.InstanceETDOCS.Delete(info); if (retValue.Codice == 0) { retValue = ((DocsPaDocumentale_OCS.Documentale.AmministrazioneManager) this.InstanceOCS).Delete(info, adminRoles); } return(retValue); }
/// <summary> /// Implementazione della logica del task di migrazione dati /// per tutti gli utenti di una singola amministrazione DocsPa /// </summary> /// <param name="infoUtente"></param> /// <param name="amministrazione"></param> public static void ImportaUtenti(InfoUtente infoUtente, InfoAmministrazione amministrazione) { // 1. Reperimento utenti dell'amministrazione OrgUtente[] users = GetUtenti(infoUtente, amministrazione); /* * if (users.Length > 0) * { * Log.GetInstance(amministrazione).Write(string.Format("Reperimento degli utenti dell'amministrazione. Numero utenti: {0}", users.Length.ToString()), false); * * DocsPaDocumentale_DOCUMENTUM.Documentale.OrganigrammaManager organigrammaManager = new DocsPaDocumentale_DOCUMENTUM.Documentale.OrganigrammaManager(infoUtente); * * foreach (OrgUtente user in users) * { * // 2. Verifica esistenza utente * if (organigrammaManager.ContainsUser(user.UserId)) * { * Log.GetInstance(amministrazione).Write(string.Format("Utente '{0}' già esistente", user.UserId), false); * } * else * { * // 3. Impostazione password di tipo amministratore per l'utente * Log.GetInstance(amministrazione).Write(string.Format("Impostazione password di tipo amministratore per l'utente '{0}'. Nuova password: '******'", user.UserId, DEFAULT_USER_PASSWORD), false); * user.Password = DEFAULT_USER_PASSWORD; * * // 4. Import di ciascun utente in DCTM * EsitoOperazione result = organigrammaManager.InserisciUtente(user); * * if (result.Codice == RESULT_CODE_OK) * { * Log.GetInstance(amministrazione).Write(string.Format("Migrazione utente '{0}'", user.UserId), false); * } * else * { * // 3a. Errore nell'import dell'utente (migrazione interrotta) * throw new ApplicationException(string.Format("Si è verificato un errore nell'import dell'utente '{0}' per l'amministrazione '{1}'. Codice: {2} - Descrizione: {3}", user.UserId, amministrazione.Codice, result.Codice.ToString(), result.Descrizione)); * } * } * } * } * else * { * // 1a. Errore nella migrazione degli utenti (migrazione interrotta) * throw new ApplicationException(string.Format("Si è verificato un errore nell'import degli utenti per l'amministrazione '{0}'. Descrizione: Nessun utente trovato", amministrazione.Codice)); * } */ }
/// <summary> /// Creazione oggetto titolario /// </summary> /// <param name="row"></param> /// <param name="infoUtente"></param> /// <param name="amministrazione"></param> /// <returns></returns> private static OrgTitolario GetTitolario(DataRow row, InfoUtente infoUtente, InfoAmministrazione amministrazione) { OrgTitolario titolario = new OrgTitolario(); titolario.ID = DataReaderHelper.GetValue <object>(row, "IDRECORD", false).ToString(); titolario.Codice = CODICE_TITOLARIO; titolario.CodiceAmministrazione = amministrazione.Codice; titolario.Descrizione = DataReaderHelper.GetValue <string>(row, "DESCRIZIONE", false); titolario.SetStatoTitolario(DataReaderHelper.GetValue <string>(row, "CHA_STATO", false)); titolario.DataAttivazione = DataReaderHelper.GetValue <DateTime>(row, "DTA_ATTIVAZIONE", false).ToString(); if (titolario.Stato == OrgStatiTitolarioEnum.Chiuso) { titolario.DataCessazione = DataReaderHelper.GetValue <DateTime>(row, "DTA_CESSAZIONE", false).ToString(); } titolario.Commento = DataReaderHelper.GetValue <string>(row, "VAR_NOTE", false); return(titolario); }
/// <summary> /// Reperimento di tutti i ruoli dell'amministrazione /// </summary> /// <param name="infoUtente"></param> /// <param name="amministrazione"></param> /// <returns></returns> private static OrgRuolo[] GetRuoli(InfoUtente infoUtente, InfoAmministrazione amministrazione) { List <OrgRuolo> list = new List <OrgRuolo>(); using (DocsPaDB.DBProvider dbProvider = new DocsPaDB.DBProvider()) { string commandText = string.Format("SELECT * FROM DPA_CORR_GLOBALI WHERE CHA_TIPO_URP = 'R' AND ID_AMM = {0} AND NOT ID_GRUPPO IS NULL", amministrazione.IDAmm); using (IDataReader reader = dbProvider.ExecuteReader(commandText)) { while (reader.Read()) { list.Add(GetRuolo(reader)); } } } return(list.ToArray()); }
/// <summary> /// /// </summary> /// <param name="infoUtente"></param> /// <param name="amministrazione"></param> /// <returns></returns> private static UserRoleEntry[] GetUserRoleEntries(InfoUtente infoUtente, InfoAmministrazione amministrazione) { List <UserRoleEntry> entries = new List <UserRoleEntry>(); using (DocsPaDB.DBProvider dbProvider = new DocsPaDB.DBProvider()) { string commandText = string.Format("SELECT PG.PEOPLE_SYSTEM_ID, PG.GROUPS_SYSTEM_ID FROM PEOPLEGROUPS PG INNER JOIN PEOPLE P ON PG.PEOPLE_SYSTEM_ID = P.SYSTEM_ID WHERE P.ID_AMM = {0} AND DTA_FINE IS NULL ORDER BY PG.PEOPLE_SYSTEM_ID ASC, PG.GROUPS_SYSTEM_ID ASC", amministrazione.IDAmm); using (IDataReader reader = dbProvider.ExecuteReader(commandText)) { while (reader.Read()) { entries.Add(new UserRoleEntry(reader)); } } } return(entries.ToArray()); }
/// <summary> /// Reperimento di tutti gli utenti dell'amministrazione /// </summary> /// <param name="infoUtente"></param> /// <param name="amministrazione"></param> /// <returns></returns> private static OrgUtente[] GetUtenti(InfoUtente infoUtente, InfoAmministrazione amministrazione) { List <OrgUtente> list = new List <OrgUtente>(); using (DocsPaDB.DBProvider dbProvider = new DocsPaDB.DBProvider()) { string commandText = string.Format("SELECT * FROM PEOPLE WHERE ID_AMM = {0} AND UPPER(USER_ID) != UPPER('{1}')", amministrazione.IDAmm, infoUtente.userId); using (IDataReader reader = dbProvider.ExecuteReader(commandText)) { while (reader.Read()) { list.Add(GetUtente(reader)); } } } return(list.ToArray()); }
/// <summary> /// /// </summary> /// <param name="info"></param> /// <returns></returns> private bool CheckRequiredFields(InfoAmministrazione info) { bool retValue = false; if (this.InfoUtente.tipoAmministratore.Equals("1")) { retValue = (!info.Codice.Trim().Equals("") && !info.Descrizione.Trim().Equals("")); } else { retValue = (!info.Codice.Trim().Equals("") && !info.Descrizione.Trim().Equals("") && !info.Fascicolatura.Trim().Equals("") && !info.Segnatura.Trim().Equals("") && !info.Timbro_pdf.Trim().Equals("") && !info.IDRagioneTO.Equals("0") && !info.IDRagioneCC.Equals("0")); } return(retValue); }
/// <summary> /// Implementazione della logica del task di migrazione dati /// per tutti i titolari di una singola amministrazione DocsPa /// </summary> /// <param name="amministrazione"></param> public static void ImportaTitolari(InfoAmministrazione amministrazione) { try { // 1. Connessione al sistema come utente amministratore //string userName = DocsPaDocumentale_DOCUMENTUM.DctmServices.DctmConfigurations.GetDocumentumSuperUser(); //string password = DocsPaDocumentale_DOCUMENTUM.DctmServices.DctmConfigurations.GetDocumentumSuperUserPwd(); string userName = "******"; string password = "******"; Log.GetInstance(amministrazione).Write(string.Format("Connessione al sistema come utente amministratore. UserName: '******' - Password: '******'", userName, password), false); UserLogin.LoginResult loginResult; InfoUtenteAmministratore infoUtente = LoginServices.LoginAdmin(userName, password, out loginResult); if (loginResult == UserLogin.LoginResult.OK) { // 2. Migrazione dati singola amministrazione ImportaTitolari(infoUtente, amministrazione); Log.GetInstance(amministrazione).Write("Procedura di migrazione completata con successo", false); } else { // 1a. Utente non autenticato throw new ApplicationException( string.Format("Errore nell'autenticazione dell'utente '{0}'. Esito:{1}", userName, loginResult.ToString())); } } catch (Exception ex) { // Migrazione annullata Log.GetInstance(amministrazione).Write(ex.Message, true); } finally { Log.GetInstance(amministrazione).Flush(); } }
/// <summary> /// Implementazione della logica del task di migrazione dati /// per associare tutti gli utenti a tutti i ruoli per una singola amministrazione DocsPa /// </summary> /// <param name="infoUtente"></param> /// <param name="amministrazione"></param> public static void ImportaAssociazioniUtentiRuoli(InfoUtente infoUtente, InfoAmministrazione amministrazione) { // 1. Reperimento dati associazione UserRoleEntry[] entries = GetUserRoleEntries(infoUtente, amministrazione); /* * DocsPaDocumentale_DOCUMENTUM.Documentale.OrganigrammaManager organigrammaManager = new DocsPaDocumentale_DOCUMENTUM.Documentale.OrganigrammaManager(infoUtente); * * foreach (UserRoleEntry entry in entries) * { * if (organigrammaManager.ContainsGroupUserById(entry.IdGroup, entry.IdPeople)) * { * // L'utente è già stato associato al ruolo * Log.GetInstance(amministrazione).Write(string.Format("Utente con id {0} già associato al gruppo con id {1}", entry.IdPeople, entry.IdGroup), false); * } * else * { * Log.GetInstance(amministrazione).Write(string.Format("Reperimento delle associazioni utenti / ruoli dell'amministrazione. Numero associazioni: {0}", entries.Length.ToString()), false); * * // 2. Associazione utente con il ruolo * EsitoOperazione retValue = organigrammaManager.InserisciUtenteInRuolo(entry.IdPeople.ToString(), entry.IdGroup.ToString()); * * if (retValue.Codice == RESULT_CODE_OK) * { * Log.GetInstance(amministrazione).Write(string.Format("Migrazione associazione utente / ruolo. IdPeople: {0} - IdGroup: {1}", entry.IdPeople.ToString(), entry.IdGroup.ToString()), false); * } * else * { * // 2a. Errore nell'associazione utente - ruolo * throw new ApplicationException( * string.Format("Si è verificato un errore nell'inserimento dell'utente con Id '{0}' nel gruppo con Id '{1}' per l'amministrazione '{2}'. Codice: {3} - Descrizione: {4}", * entry.IdPeople.ToString(), entry.IdGroup.ToString(), amministrazione.Codice, retValue.Codice.ToString(), retValue.Descrizione) * ); * } * } * } */ }
/// <summary> /// Inserimento di una nuova amministrazione nel documentale /// </summary> /// <param name="info"></param> /// <returns></returns> public EsitoOperazione Insert(InfoAmministrazione info) { EsitoOperazione esito = new EsitoOperazione(); DocsPaDB.Query_DocsPAWS.Amministrazione dmAmm = new DocsPaDB.Query_DocsPAWS.Amministrazione(); // campo codice univoco if (dmAmm.ContainsAmministrazione(info)) { esito.Codice = 2; esito.Descrizione = "il campo CODICE è già utilizzato da altra amministrazione"; return(esito); } // campi obbligatori if (!this.CheckRequiredFields(info)) { esito.Codice = 1; esito.Descrizione = "inserire tutti i campi obbligatori"; return(esito); } // verifica campi numerici if (!string.IsNullOrEmpty(info.PortaSMTP) && !this.IsNumeric(info.PortaSMTP)) { esito.Codice = 2; esito.Descrizione = "il campo PORTA SMTP deve avere un valore numerico"; return(esito); } if (!string.IsNullOrEmpty(info.SslSMTP) && !this.IsNumeric(info.SslSMTP)) { esito.Codice = 2; esito.Descrizione = "il campo SSL SMTP deve avere un valore numerico"; return(esito); } if (info.AttivaGGPermanenzaTDL.Equals("1")) { if (!string.IsNullOrEmpty(info.GGPermanenzaTDL)) { if (!this.IsNumeric(info.GGPermanenzaTDL)) { esito.Codice = 2; esito.Descrizione = "il campo che indica i giorni nella funzionalità di avviso relativo alle 'Cose da fare' deve avere un valore numerico"; return(esito); } } else { esito.Codice = 2; esito.Descrizione = "è stata attivata la funzionalità di avviso delle trasmissioni nelle 'Cose da fare' ma non sono stati specificati i giorni"; return(esito); } } else { if (info.AttivaGGPermanenzaTDL.Equals("0")) { info.GGPermanenzaTDL = "NULL"; } } string errorMessage; // Inserimento nuova amministrazione if (!dmAmm.InsertAmministrazione(info, out errorMessage)) { esito.Codice = 3; esito.Descrizione = errorMessage; } return(esito); }
/// <summary> /// Aggiornamento di un'amministrazione esistente nel documentale /// </summary> /// <param name="info"></param> /// <returns></returns> public EsitoOperazione Update(InfoAmministrazione info) { return(this.InstanceETDOCS.Update(info)); }
/// <summary> /// Inserimento di una nuova amministrazione nel documentale /// /// Problema delle DFS: /// come da documentazione, inizialmente gli inserimenti venivano effettuati /// tutti in un'unica operazione. Il problema è che le cartelle DNC e StampaRegistro /// venivano create nel folder HomeCabinet (oltre che normalmente nel cabinet dell'amministrazione). /// Ciò sicuramente è dovuto al fatto di inserire tutto in un'unica richiesta. /// Per ovviare a questo inconveniente, si è scelto di inserire le cartelle in 2 fasi: /// 1. inserimento cabinet 2. inserimento cartelle sottostanti /// </summary> /// <param name="info"></param> /// <returns></returns> public EsitoOperazione Insert(InfoAmministrazione info) { EsitoOperazione retValue = new EsitoOperazione(); // ACL per l'amministrazione CustomServices.AclDefinition aclDefinition = null; // Identity del cabinet dell'amministrazione ObjectIdentity cabinetIdentity = null; // Identity del gruppo di sistema associato all'amministrazione ObjectIdentity groupIdentity = null; // Identity del gruppo di sistema che contiene gli amministratori dell'amministrazione ObjectIdentity adminGroupIdentity = null; try { // Creazione del cabinet per l'amministrazione ObjectPath cabinetPath = this.GetCabinetPath(info); logger.Debug("cabinetPath " + cabinetPath); cabinetIdentity = this.GetObjectServiceInstance().CreatePath(cabinetPath, DctmConfigurations.GetRepositoryName()); // Creazione documenti ObjectIdentity documentiIdentity = new ObjectIdentity(DctmConfigurations.GetRepositoryName()); DataObject dataObjectDocumenti = new DataObject(documentiIdentity, "dm_folder"); dataObjectDocumenti.Properties.Set <string>("object_name", DocsPaAdminCabinet.FOLDER_DOCUMENTI); dataObjectDocumenti.Relationships.Add(new ReferenceRelationship(cabinetIdentity, Relationship.RELATIONSHIP_FOLDER, Relationship.ROLE_PARENT)); // Creazione folder titolario ObjectIdentity titolarioIdentity = new ObjectIdentity(DctmConfigurations.GetRepositoryName()); DataObject dataObjectTitolario = new DataObject(titolarioIdentity, "dm_folder"); dataObjectTitolario.Properties.Set <string>("object_name", DocsPaAdminCabinet.FOLDER_TITOLARIO); dataObjectTitolario.Relationships.Add(new ReferenceRelationship(cabinetIdentity, Relationship.RELATIONSHIP_FOLDER, Relationship.ROLE_PARENT)); // Creazione del gruppo di sistema associato all'amministrazione groupIdentity = new ObjectIdentity(DctmConfigurations.GetRepositoryName()); DataObject groupData = new DataObject(groupIdentity, ObjectTypes.GRUPPO); groupData.Properties.Set <string>("group_name", TypeGruppo.GetGroupNameForAmministrazione(info.Codice)); groupData.Properties.Set <string>("description", "Gruppo di sistema: tutti gli utenti dell'amministrazione " + info.Codice); groupData.Properties.Set <string>("group_class", "group"); // Creazione del gruppo di sistema che contiene gli amministratori dell'amministrazione //adminGroupIdentity = new ObjectIdentity(DctmConfigurations.GetRepositoryName().ToLower()); //<- PERCHE' TO LOWER!? (Vecchio 6.0) adminGroupIdentity = new ObjectIdentity(DctmConfigurations.GetRepositoryName()); DataObject adminGroupData = new DataObject(adminGroupIdentity, ObjectTypes.GRUPPO); adminGroupData.Properties.Set <string>("group_name", TypeGruppo.GetGroupNameForSysAdminAmministrazione(info.Codice)); adminGroupData.Properties.Set <string>("description", "Gruppo di sistema: sysadmin dell'amministrazione " + info.Codice); adminGroupData.Properties.Set <string>("group_class", "group"); DataPackage dataPackage = new DataPackage(); dataPackage.AddDataObject(dataObjectDocumenti); dataPackage.AddDataObject(dataObjectTitolario); dataPackage.AddDataObject(groupData); dataPackage.AddDataObject(adminGroupData); dataPackage = this.GetObjectServiceInstance().Create(dataPackage, null); if (dataPackage.DataObjects.Count == 0) { throw new ApplicationException("Nessun oggetto creato"); } else { dataObjectDocumenti = dataPackage.DataObjects[0]; dataObjectTitolario = dataPackage.DataObjects[1]; groupIdentity = dataPackage.DataObjects[2].Identity; adminGroupIdentity = dataPackage.DataObjects[3].Identity; // Creazione AclDefinition per tutti gli oggetti dell'amministrazione aclDefinition = this.CreateAclAdmin(info); // Associazione dell'ACL appena creata con gli oggetti dell'amministrazione AclHelper.setAclObjectProperties(dataObjectDocumenti.Properties, aclDefinition); AclHelper.setAclObjectProperties(dataObjectTitolario.Properties, aclDefinition); dataPackage = new DataPackage(); dataPackage.AddDataObject(dataObjectDocumenti); dataPackage.AddDataObject(dataObjectTitolario); dataPackage = this.GetObjectServiceInstance().Update(dataPackage, null); logger.Debug(string.Format("Documentum.InsertAmministrazione: {0} oggetti creati per nuova amministrazione {1}, CabinetPath {2}", dataPackage.DataObjects.Count.ToString(), info.Codice, cabinetPath.Path)); } } catch (Exception ex) { // In caso di errore, viene annullata la procedura // rimuovendo gli oggetti finora inseriti if (aclDefinition != null) { try { // Rimozione ACL appena inserita this.DeleteAclAdmin(aclDefinition); } catch (Exception exInner) { logger.Debug(string.Format("Documentum.InsertAmministrazione: errore in rimozione acl '{0}'", aclDefinition.name)); } } // Inserimento nell'identityset degli oggetti da rimuovere ObjectIdentitySet createdObjects = new ObjectIdentitySet(); if (cabinetIdentity != null && cabinetIdentity.ValueType == ObjectIdentityType.OBJECT_ID) { createdObjects.AddIdentity(cabinetIdentity); } if (groupIdentity != null && groupIdentity.ValueType == ObjectIdentityType.OBJECT_ID) { createdObjects.AddIdentity(groupIdentity); } if (adminGroupIdentity != null && adminGroupIdentity.ValueType == ObjectIdentityType.OBJECT_ID) { createdObjects.AddIdentity(adminGroupIdentity); } if (createdObjects.Identities.Count > 0) { OperationOptions opts = new OperationOptions(); opts.DeleteProfile = this.CreateDeleteProfile(); try { // Rimozione di tutti gli oggetti creati per l'amministrazione this.GetObjectServiceInstance().Delete(createdObjects, opts); } catch (Exception exInner) { logger.Debug(string.Format("Documentum.InsertAmministrazione: errore in rimozione cabinet amministrazione '{0}'", info.Codice)); } } logger.Debug(string.Format("Errore in Documentum.InsertAmministrazione:\n{0}", ex.ToString())); retValue.Codice = -1; retValue.Descrizione = string.Format("Errore nella creazione del cabinet {0} in Documentum", info.Codice); } return(retValue); }
/// <summary> /// Creazione ObjectPath relativamente al cabinet che rappresenta l'amministrazione di docspa in documentum /// </summary> /// <param name="info"></param> /// <returns></returns> protected ObjectPath GetCabinetPath(InfoAmministrazione info) { return(new ObjectPath(string.Format("{0}/", DocsPaAdminCabinet.getRootAmministrazione(info.Codice)))); }
/////// <summary> /////// Reperimento di tutti gli utenti dell'amministrazione /////// </summary> /////// <param name="infoUtente"></param> /////// <param name="amministrazione"></param> /////// <returns></returns> ////private static string[] GetUtenti(InfoAmministrazione amm) ////{ //// List<string> list = new List<string>(); //// using (DocsPaDB.DBProvider dbProvider = new DocsPaDB.DBProvider()) //// { //// string commandText = string.Format("SELECT user_id FROM PEOPLE WHERE id_amm = {0}", amm.IDAmm); //// using (System.Data.IDataReader reader = dbProvider.ExecuteReader(commandText)) //// { //// while (reader.Read()) //// { //// list.Add(DocsPaUtils.Data.DataReaderHelper.GetValue<string>(reader, "user_id", false)); //// } //// } //// } //// return list.ToArray(); ////} /// <summary> /// Cancellazione di un'amministrazione nel documentale. /// NB: L'operazione di rimozione deve essere effettuata con le credenziali /// dell'utente superuser /// </summary> /// <param name="info"></param> /// <param name="ruoliAmministrazione"> /// Ruoli docspa da rimuovere in documentum /// </param> /// <returns></returns> public EsitoOperazione Delete(InfoAmministrazione info, string[] ruoliAmministrazione) { logger.Debug(string.Format("Documentum.DeleteAmministrazione: inizio rimozione amministrazione. Codice: '{0}'", info.Codice)); EsitoOperazione retValue = new EsitoOperazione(); try { ObjectIdentitySet identitySet = new ObjectIdentitySet(); // Reperimento degli oggetti Identity relativi a tutti i gruppi e gli utenti dell'amministrazione IQueryService queryService = DctmServiceFactory.GetServiceInstance <IQueryService>(this.InfoUtente.dst); string[] users = Dfs4DocsPa.getUsersSystemGroup(info.Codice, queryService); // Cancellazione di tutti gli utenti legati al cabinet / amministrazione foreach (string userId in users) { string normalizedUserId = TypeUtente.NormalizeUserName(userId); // Reperimento oggetto identity per ogni utente identitySet.AddIdentity(Dfs4DocsPa.getUserIdentityByName(normalizedUserId)); // Cancellazione dell'home cabinet per ogni 'utente identitySet.AddIdentity(Dfs4DocsPa.getUserHomeFolderIdentity(normalizedUserId)); logger.Debug(string.Format("Documentum.DeleteAmministrazione: rimozione utente '{0}'", normalizedUserId)); } //foreach (string userId in GetUtenti(info)) //{ // string normalizedUserId = TypeUtente.NormalizeUserName(userId); // ObjectIdentity id = Dfs4DocsPa.getUserIdentityByName(normalizedUserId, queryService); // if (id != null) // { // identitySet.AddIdentity(id); // // Cancellazione dell'home cabinet per ogni 'utente // identitySet.AddIdentity(Dfs4DocsPa.getUserHomeFolderIdentity(normalizedUserId)); // } //} // Cancellazione del ruolo di sistema dell'amministrazione ObjectIdentity identity = Dfs4DocsPa.getSystemGroupIdentity(info.Codice, queryService); if (identity != null) { identitySet.AddIdentity(identity); } // Cancellazione del ruolo di sistema degli amministratori dell'amministrazione identity = Dfs4DocsPa.getAmmSystemGroupIdentity(info.Codice, queryService); if (identity != null) { identitySet.AddIdentity(identity); } // Cancellazione di tutti gli gruppi legati al cabinet / amministrazione foreach (string docspaGroupName in ruoliAmministrazione) { string normalizedGroupName = TypeGruppo.NormalizeGroupName(docspaGroupName); ObjectIdentity groupIdentity = Dfs4DocsPa.getGroupIdentityByName(normalizedGroupName, queryService); if (groupIdentity != null) { identitySet.AddIdentity(groupIdentity); logger.Debug(string.Format("Documentum.DeleteAmministrazione: rimozione ruolo '{0}'", normalizedGroupName)); } } // Reperimento oggetto Identity relativamente al cabinet da rimuovere identitySet.AddIdentity(Dfs4DocsPa.getCabinetIdentity(info.Codice)); OperationOptions opts = new OperationOptions(); opts.DeleteProfile = this.CreateDeleteProfile(); IObjectService objectService = this.GetObjectServiceInstance(); objectService.Delete(identitySet, opts); logger.Debug(string.Format("Documentum.DeleteAmministrazione: rimozione amministrazione. Codice: '{0}'", info.Codice)); // Cancellazione di tutte le ACL create per gli oggetti dell'amministrazione this.DeleteAcl(info); logger.Debug(string.Format("Documentum.DeleteAmministrazione: rimozione ACL amministrazione. Codice: '{0}'", info.Codice)); } catch (Exception ex) { logger.Debug(string.Format("Errore in Documentum.DeleteAmministrazione:\n{0}", ex.ToString())); retValue.Codice = -1; retValue.Descrizione = string.Format("Errore nella rimozione del cabinet {0} in Documentum", info.Codice); } return(retValue); }
/// <summary> /// Cancellazione di un'amministrazione nel documentale /// </summary> /// <param name="info"></param> /// <returns></returns> public EsitoOperazione Delete(InfoAmministrazione info) { return(this.Delete(info, DocsPaQueryHelper.getGroupNames(info.IDAmm))); }