/// <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)));
}
