/// <summary>
///
/// </summary>
/// <param name="nodoTitolario"></param>
/// <param name="ruoloTitolario"></param>
/// <returns></returns>
public bool SetAclRuoloNodoTitolario(OrgNodoTitolario nodoTitolario, OrgRuoloTitolario ruoloTitolario)
{
// Cancellazione dati del titolario nel documentale ETDOCS
bool retValue = this.TitolarioManagerETDOCS.SetAclRuoloNodoTitolario(nodoTitolario, ruoloTitolario);
return(retValue);
}
/// <summary>
/// Eliminazione di un nodo di titolario
/// </summary>
/// <param name="nodoTitolario"></param>
/// <returns></returns>
public bool DeleteNodoTitolario(OrgNodoTitolario nodoTitolario)
{
bool retValue = true;
// ... non fa nulla
return(retValue);
}
/// <summary>
/// Aggiornamento visibilità di più ruoli su un titolario
/// </summary>
/// <param name="nodoTitolario"></param>
/// <param name="ruoliTitolario"></param>
/// <returns></returns>
public DocsPaVO.amministrazione.EsitoOperazione[] SetAclNodoTitolario(OrgNodoTitolario nodoTitolario, OrgRuoloTitolario[] ruoliTitolario)
{
// Per documentum, viene riportato un'unico EsitoOperazione
// contenente i dettagli relativi all'esito dell'intera operazione effettuata
// (a differenza di etdocs, l'aggiornamento è effetuato in un'unica operazione)
EsitoOperazione retValue = new EsitoOperazione();
try
{
// Reperimento ACL del nodo titolario
CustomServices.AclDefinition aclData = Dfs4DocsPa.getAclDefinition(nodoTitolario.ID, ObjectTypes.NODO_TITOLARIO, nodoTitolario.CodiceAmministrazione);
CustomServices.IAclService aclService = DctmServiceFactory.GetCustomServiceInstance <CustomServices.IAclService>(UserManager.ImpersonateSuperUser());
// Aggiornamento della visibilità dei ruoli sul nodo titolario
aclService.ClearAndGrant(aclData);
retValue.Codice = 0;
retValue.Descrizione = string.Format("Aggiornamento dei ruoli nel nodo titolario '{0}' terminato correttamente", nodoTitolario.Codice);
}
catch (Exception ex)
{
retValue.Codice = -1;
retValue.Descrizione = string.Format("Errore in Documentum nell'aggiornamento dei ruoli nel nodo titolario '{0}'", nodoTitolario.Codice);
logger.Debug("Errore in Documentum.SetAclNodoTitolario: " + ex.ToString());
}
return(new EsitoOperazione[1] {
retValue
});
}
/// <summary>
/// Impostazione / rimozione della visibilità di un singolo nodo di titolario per un ruolo
/// </summary>
/// <param name="nodoTitolario"></param>
/// <param name="ruoloTitolario">
/// Ruolo cui deve essere associata / rimossa la visibilità verso il nodo titolario
/// </param>
/// <returns></returns>
public bool SetAclRuoloNodoTitolario(OrgNodoTitolario nodoTitolario, OrgRuoloTitolario ruoloTitolario)
{
bool retValue = true;
// ... non fa nulla
return(retValue);
}
/// <summary>
///
/// </summary>
/// <param name="nodoTitolario"></param>
/// <returns></returns>
public bool SaveNodoTitolario(OrgNodoTitolario nodoTitolario)
{
// Aggiornamento dati del titolario nel documentale ETDOCS
bool saved = this.TitolarioManagerETDOCS.SaveNodoTitolario(nodoTitolario);
return(saved);
}
/// <summary>
/// Aggiornamento visibilità di più ruoli su un titolario
/// </summary>
/// <param name="nodoTitolario"></param>
/// <param name="ruoliTitolario"></param>
/// <returns></returns>
public DocsPaVO.amministrazione.EsitoOperazione[] SetAclNodoTitolario(OrgNodoTitolario nodoTitolario, OrgRuoloTitolario[] ruoliTitolario)
{
// Aggiornamento delle acl di un nodo titolario per il documentale ETDOCS
EsitoOperazione[] esitoOperazione = this.TitolarioManagerETDOCS.SetAclNodoTitolario(nodoTitolario, ruoliTitolario);
return(esitoOperazione);
}
/// <summary>
/// Aggiornamento visibilità di più ruoli su un titolario
/// </summary>
/// <param name="nodoTitolario"></param>
/// <param name="ruoliTitolario"></param>
/// <returns></returns>
public DocsPaVO.amministrazione.EsitoOperazione[] SetAclNodoTitolario(OrgNodoTitolario nodoTitolario, OrgRuoloTitolario[] ruoliTitolario)
{
// Aggiornamento delle acl di un nodo titolario per il documentale ETDOCS
EsitoOperazione[] esitoOperazione = this.TitolarioManagerETDOCS.SetAclNodoTitolario(nodoTitolario, ruoliTitolario);
if (esitoOperazione != null && esitoOperazione.Length > 0)
{
//// Dall'esito dell'operazione in ETDOCS, reperimento dei ruoli aggiornati correttamente (attributo "Codice" == 0)
//var ruoliNonAggiornati = esitoOperazione.Where(e => e.Codice != 0);
//OrgRuoloTitolario[] ruoliTitolarioDctm = null;
//if (ruoliNonAggiornati.Count() > 0)
// // Reperimento dei soli ruoli che sono stati aggiornati correttamente in etdocs
// ruoliTitolarioDctm = ruoliTitolario.Any(e => e.ID != (from c in ruoliNonAggiornati select c.Codice.ToString())).ToArray();
//else
// ruoliTitolarioDctm = ruoliTitolario;
//var d = (from c in ruoliTitolario join
// x in ruoliNonAggiornati on c.ID equals x.Codice.ToString()
// select c);
EsitoOperazione[] esitoOperazioneDctm = this.TitolarioManagerDCTM.SetAclNodoTitolario(nodoTitolario, ruoliTitolario);
if (esitoOperazioneDctm[0].Codice == -1)
{
// Errore nell'aggiornamento in Documentum
esitoOperazione = esitoOperazioneDctm;
}
}
return(esitoOperazione);
}
/// <summary>
///
/// </summary>
/// <param name="nodoTitolario"></param>
/// <returns></returns>
public bool DeleteNodoTitolario(OrgNodoTitolario nodoTitolario)
{
// Cancellazione dati del titolario nel documentale ETDOCS
bool deleted = this.TitolarioManagerETDOCS.DeleteNodoTitolario(nodoTitolario);
return(deleted);
}
/// <summary>
/// Rimozione di tutte le ACL dei fascicoli procedimentali contenuti nel titolario
/// </summary>
/// <param name="nodoTitolario"></param>
protected void ClearAclFascicoliNodoTitolario(OrgNodoTitolario nodoTitolario)
{
foreach (string idFascicolo in DocsPaQueryHelper.getFascicoliProcedimentaliNodoTitolario(nodoTitolario.ID))
{
// Reperimento e cancellazione ACL per il fascicolo procedimentale
CustomServices.AclDefinition aclDefinition = Dfs4DocsPa.getAclDefinition(idFascicolo, ObjectTypes.FASCICOLO, this.InfoUtente);
this.DeleteAcl(aclDefinition);
}
}
public XmlFascicolo(InfoConservazione infoCons, string ID_Project, FolderConservazione[] folderConservazione)
{
if (fascicolo == null)
{
fascicolo = new Fascicolo.Fascicolo();
}
DocsPaVO.utente.Ruolo ruolo = BusinessLogic.Utenti.UserManager.getRuolo(infoCons.IdRuoloInUo);
DocsPaVO.utente.Utente Utente = UserManager.getUtente(infoCons.IdPeople);
DocsPaVO.utente.UnitaOrganizzativa unitaOrganizzativa = ruolo.uo;
DocsPaVO.utente.InfoUtente infoUtente = UserManager.GetInfoUtente(Utente, ruolo);
DocsPaVO.fascicolazione.Fascicolo dpaFascicolo = BusinessLogic.Fascicoli.FascicoloManager.getFascicoloById(ID_Project, infoUtente);
List <UnitaOrganizzativa> uoL = new List <UnitaOrganizzativa>();
UnitaOrganizzativa uoXML = Utils.convertiUO(unitaOrganizzativa);
uoL.Add(uoXML);
fascicolo.SoggettoProduttore = new SoggettoProduttore
{
Amministrazione = Utils.getInfoAmministrazione(infoCons),
GerarchiaUO = new GerarchiaUO {
UnitaOrganizzativa = uoL.ToArray()
},
Creatore = Utils.getCreatore(infoCons, ruolo)
};
if (dpaFascicolo != null && dpaFascicolo.template != null)
{
Tipologia t = new Tipologia {
NomeTipologia = dpaFascicolo.template.DESCRIZIONE, CampoTipologia = Utils.getCampiTipologia(dpaFascicolo.template)
};
fascicolo.Tipologia = t;
}
if (!string.IsNullOrEmpty(fascicolo.Codice))
{
fascicolo.Codice = dpaFascicolo.codice;
fascicolo.DataChiusura = Utils.formattaData(Utils.convertiData(dpaFascicolo.chiusura));
fascicolo.DataCreazione = Utils.formattaData(Utils.convertiData(dpaFascicolo.apertura));
fascicolo.Descrizione = dpaFascicolo.descrizione;
OrgNodoTitolario nodo = BusinessLogic.Amministrazione.TitolarioManager.getNodoTitolario(dpaFascicolo.idTitolario);
fascicolo.TitolarioDiRiferimento = nodo.Descrizione;
fascicolo.Classificazione = nodo.Codice;
fascicolo.LivelloRiservatezza = Utils.convertiLivelloRiservatezza(dpaFascicolo.privato);
fascicolo.Numero = dpaFascicolo.numFascicolo;
fascicolo.Contenuto = creaStrutturaContenuto(folderConservazione, ID_Project, infoUtente, ref fascicolo);
}
}
/// <summary>
///
/// </summary>
/// <param name="nodoTitolario"></param>
/// <returns></returns>
public bool DeleteNodoTitolario(OrgNodoTitolario nodoTitolario)
{
// Cancellazione dati del titolario nel documentale ETDOCS
bool deleted = this.TitolarioManagerETDOCS.DeleteNodoTitolario(nodoTitolario);
if (deleted)
{
// Se l'inserimento è andato a buon fine,
// Cancellazione dati del titolario nel documentale OCS
deleted = this.TitolarioManagerOCS.DeleteNodoTitolario(nodoTitolario);
}
return(deleted);
}
/// <summary>
///
/// </summary>
/// <param name="nodoTitolario"></param>
/// <param name="ruoloTitolario"></param>
/// <returns></returns>
public bool SetAclRuoloNodoTitolario(OrgNodoTitolario nodoTitolario, OrgRuoloTitolario ruoloTitolario)
{
// Cancellazione dati del titolario nel documentale ETDOCS
bool retValue = this.TitolarioManagerETDOCS.SetAclRuoloNodoTitolario(nodoTitolario, ruoloTitolario);
if (retValue)
{
// Se l'inserimento è andato a buon fine,
// Cancellazione dati del titolario nel documentale OCS
retValue = this.TitolarioManagerOCS.SetAclRuoloNodoTitolario(nodoTitolario, ruoloTitolario);
}
return(retValue);
}
/// <summary>
///
/// </summary>
/// <param name="nodoTitolario"></param>
/// <returns></returns>
public bool SaveNodoTitolario(OrgNodoTitolario nodoTitolario)
{
// Aggiornamento dati del titolario nel documentale ETDOCS
bool saved = this.TitolarioManagerETDOCS.SaveNodoTitolario(nodoTitolario);
if (saved)
{
// Se l'inserimento è andato a buon fine,
// Aggiornamento dati del titolario nel documentale OCS
saved = this.TitolarioManagerOCS.SaveNodoTitolario(nodoTitolario);
}
return(saved);
}
/// <summary>
///
/// </summary>
/// <param name="nodoTitolario"></param>
/// <param name="ruoloTitolario"></param>
/// <returns></returns>
public bool SetAclRuoloNodoTitolario(OrgNodoTitolario nodoTitolario, OrgRuoloTitolario ruoloTitolario)
{
// Cancellazione dati del titolario nel documentale ETDOCS
bool retValue = this.TitolarioManagerETDOCS.SetAclRuoloNodoTitolario(nodoTitolario, ruoloTitolario);
/*
* if (retValue)
* {
* // Se l'inserimento è andato a buon fine,
* // Cancellazione dati del titolario nel documentale DOCUMENTUM
* retValue = this.TitolarioManagerDCTM.SetAclRuoloNodoTitolario(nodoTitolario, ruoloTitolario);
* }
*/
return(retValue);
}
/// <summary>
///
/// </summary>
/// <param name="nodoTitolario"></param>
/// <returns></returns>
public bool SaveNodoTitolario(OrgNodoTitolario nodoTitolario)
{
// Aggiornamento dati del titolario nel documentale ETDOCS
bool saved = this.TitolarioManagerETDOCS.SaveNodoTitolario(nodoTitolario);
/*
* if (saved)
* {
* // Se l'inserimento è andato a buon fine,
* // Aggiornamento dati del titolario nel documentale DOCUMENTUM
* saved = this.TitolarioManagerDCTM.SaveNodoTitolario(nodoTitolario);
* }
*/
return(saved);
}
/// <summary>
///
/// </summary>
/// <param name="nodoTitolario"></param>
/// <returns></returns>
public bool DeleteNodoTitolario(OrgNodoTitolario nodoTitolario)
{
// Cancellazione dati del titolario nel documentale ETDOCS
bool deleted = this.TitolarioManagerETDOCS.DeleteNodoTitolario(nodoTitolario);
/*
* if (deleted)
* {
* // Se l'inserimento è andato a buon fine,
* // Cancellazione dati del titolario nel documentale DOCUMENTUM
* deleted = this.TitolarioManagerDCTM.DeleteNodoTitolario(nodoTitolario);
* }
*/
return(deleted);
}
/// <summary>
/// Inserimento di un nuovo nodo di titolario
/// </summary>
/// <param name="nodoTitolario"></param>
/// <returns></returns>
public bool SaveNodoTitolario(OrgNodoTitolario nodoTitolario)
{
bool saved = false;
using (DocsPaDB.Query_DocsPAWS.Amministrazione amm = new DocsPaDB.Query_DocsPAWS.Amministrazione())
{
if (string.IsNullOrEmpty(nodoTitolario.ID))
{
EsitoOperazione esito = amm.InsertNodoTitolario(ref nodoTitolario);
saved = (esito.Codice == 0);
}
else
{
saved = amm.UpdateNodoTitolario(nodoTitolario);
}
}
return(saved);
}
/// <summary>
/// Eliminazione di un nodo di titolario
/// </summary>
/// <param name="nodoTitolario"></param>
/// <returns></returns>
public bool DeleteNodoTitolario(OrgNodoTitolario nodoTitolario)
{
bool retValue = false;
try
{
IObjectService objSrvc = this.GetObjectServiceInstance();
DeleteProfile deleteProfile = new DeleteProfile();
deleteProfile.IsDeepDeleteFolders = true;
deleteProfile.IsDeepDeleteChildrenInFolders = true;
OperationOptions opts = new OperationOptions();
opts.Profiles = new List <Profile>();
opts.Profiles.Add(deleteProfile);
ObjectIdentitySet identitySet = new ObjectIdentitySet();
identitySet.Identities = new List <ObjectIdentity>();
identitySet.Identities.Add(Dfs4DocsPa.getNodoTitolarioIdentity(nodoTitolario.ID));
objSrvc.Delete(identitySet, opts);
// Rimozione ACL nodo titolario
this.DeleteAclNodoTitolario(nodoTitolario);
// Rimozione di tutte le ACL degli eventuali
// fascicoli procedimentali contenuti nel titolario
this.ClearAclFascicoliNodoTitolario(nodoTitolario);
retValue = true;
logger.Debug(string.Format("Documentum.DeleteNodoTitolario: rimosso nodo di titolario con id {0}", nodoTitolario.ID));
}
catch (Exception ex)
{
retValue = false;
logger.Debug("Errore in Documentum.DeleteNodoTitolario: " + ex.ToString());
}
return(retValue);
}
/// <summary>
/// Impostazione / rimozione della visibilità di un singolo nodo di titolario per un ruolo
/// </summary>
/// <param name="nodoTitolario"></param>
/// <param name="ruoloTitolario">
/// Ruolo cui deve essere associata / rimossa la visibilità verso il nodo titolario
/// </param>
/// <returns></returns>
public bool SetAclRuoloNodoTitolario(OrgNodoTitolario nodoTitolario, OrgRuoloTitolario ruoloTitolario)
{
bool retValue = false;
try
{
// Reperimento ACL associate al nodo di titolario SOLO per il ruolo richiesto
CustomServices.AclDefinition aclData = AclHelper.getAclDefinition(nodoTitolario.CodiceAmministrazione, nodoTitolario.ID, ObjectTypes.NODO_TITOLARIO);
List <CustomServices.AclEntry> entries = new List <CustomServices.AclEntry>(aclData.entries);
//AclHelper.addBasicPermit(entries, TypeGruppo.NormalizeGroupName(ruoloTitolario.Codice), Permission.DELETE);
AclHelper.addBasicPermit(entries, TypeGruppo.NormalizeGroupName(DocsPaQueryHelper.getCodiceRuoloFromIdGroups(ruoloTitolario.ID)), Permission.DELETE);
aclData.entries = entries.ToArray();
CustomServices.IAclService aclService = DctmServiceFactory.GetCustomServiceInstance <CustomServices.IAclService>(UserManager.ImpersonateSuperUser());
if (ruoloTitolario.Associato)
{
// Impostazione visibilità del ruolo
aclService.UpdateWithGrant(aclData);
}
else
{
// Rimozione visibilità del ruolo
aclService.Revoke(aclData);
}
retValue = true;
}
catch (Exception ex)
{
retValue = false;
logger.Debug("Errore in Documentum.SetAclRuoloNodoTitolario: " + ex.ToString());
}
return(retValue);
}
public bool DeleteNodoTitolario(OrgNodoTitolario nodoTitolario)
{
return(this.Instance.DeleteNodoTitolario(nodoTitolario));
}
public bool SetAclRuoloNodoTitolario(OrgNodoTitolario nodoTitolario, OrgRuoloTitolario ruoloTitolario)
{
return(this.Instance.SetAclRuoloNodoTitolario(nodoTitolario, ruoloTitolario));
}
private ContestoArchivistico getContestoArchivistico(InfoConservazione infoCons, DocsPaVO.documento.SchedaDocumento schDoc, DocsPaVO.utente.Ruolo ruolo, DocsPaVO.utente.InfoUtente infoUtente)
{
ContestoArchivistico retval = new ContestoArchivistico();
List <Fascicolazione> fasList = new List <Fascicolazione>();
List <Classificazione> titList = new List <Classificazione>();
object[] fasAList = BusinessLogic.Fascicoli.FascicoloManager.getFascicoliDaDocNoSecurity(infoUtente, schDoc.systemId).ToArray();
foreach (object fo in fasAList)
{
DocsPaVO.fascicolazione.Fascicolo fas = fo as DocsPaVO.fascicolazione.Fascicolo;
if (fas != null)
{
if (fas.tipo == "P")
{
Fascicolazione fascicolazione = new Fascicolazione();
fascicolazione.DescrizioneFascicolo = fas.descrizione;
fascicolazione.CodiceFascicolo = fas.codice;
fascicolazione.CodiceSottofascicolo = null;
fascicolazione.DescrizioneSottofascicolo = null;
fasList.Add(fascicolazione);
if (fas.idTitolario != null)
{
OrgNodoTitolario nodo = BusinessLogic.Amministrazione.TitolarioManager.getNodoTitolario(fas.idTitolario);
fascicolazione.TitolarioDiRierimento = nodo.Descrizione;
}
foreach (DocsPaVO.fascicolazione.Folder f in BusinessLogic.Fascicoli.FolderManager.GetFoldersDocument(schDoc.systemId, fas.systemID))
{
Fascicolazione fasFolder = new Fascicolazione();
fasFolder.CodiceFascicolo = fas.descrizione;
fasFolder.DescrizioneFascicolo = fas.codice;
fasFolder.CodiceSottofascicolo = f.systemID;
fasFolder.DescrizioneSottofascicolo = f.descrizione;
fasFolder.TitolarioDiRierimento = fascicolazione.TitolarioDiRierimento;
fasList.Add(fasFolder);
}
}
else
{
OrgNodoTitolario nodo = BusinessLogic.Amministrazione.TitolarioManager.getNodoTitolario(fas.idTitolario);
Classificazione cl = new Classificazione();
cl.TitolarioDiRiferimento = nodo.Descrizione;
cl.CodiceClassificazione = nodo.Codice;
titList.Add(cl);
}
}
}
List <DocumentoCollegato> lstDocColl = new List <DocumentoCollegato>();
if (schDoc.rispostaDocumento != null)
{
if ((schDoc.rispostaDocumento.docNumber != null) && (schDoc.rispostaDocumento.idProfile != null))
{
SchedaDocumento sc = BusinessLogic.Documenti.DocManager.getDettaglio(infoUtente, schDoc.rispostaDocumento.idProfile, schDoc.rispostaDocumento.docNumber);
DocumentoCollegato docColl = new DocumentoCollegato
{
IDdocumento = schDoc.rispostaDocumento.idProfile,
DataCreazione = Utils.formattaData(Utils.convertiData(sc.dataCreazione)),
Oggetto = sc.oggetto.descrizione,
};
if (sc.protocollo != null)
{
docColl.DataProtocollo = Utils.formattaData(Utils.convertiData(sc.protocollo.dataProtocollazione));
docColl.NumeroProtocollo = sc.protocollo.numero;
docColl.SegnaturaProtocollo = sc.protocollo.segnatura;
}
lstDocColl.Add(docColl);
}
}
retval.Fascicolazione = fasList.ToArray();
retval.Classificazione = titList.ToArray();
retval.DocumentoCollegato = lstDocColl.ToArray();
return(retval);
}
public bool SaveNodoTitolario(OrgNodoTitolario nodoTitolario)
{
return(this.Instance.SaveNodoTitolario(nodoTitolario));
}
/// <summary>
/// Creazione oggetto nodo di titolario
/// </summary>
/// <param name="row"></param>
/// <param name="infoUtente"></param>
/// <param name="amministrazione"></param>
/// <returns></returns>
private static OrgNodoTitolario GetNodoTitolario(DataRow row, InfoUtente infoUtente, InfoAmministrazione amministrazione)
{
OrgNodoTitolario nodoTitolario = new OrgNodoTitolario();
nodoTitolario.ID = DataReaderHelper.GetValue <decimal>(row, "IDRECORD", false).ToString();
nodoTitolario.Codice = DataReaderHelper.GetValue <string>(row, "CODICE", false);
nodoTitolario.CodiceAmministrazione = amministrazione.Codice;
nodoTitolario.Descrizione = DataReaderHelper.GetValue <string>(row, "DESCRIZIONE", false);
nodoTitolario.Livello = DataReaderHelper.GetValue <decimal>(row, "LIVELLO", false).ToString();
string idRegistro = DataReaderHelper.GetValue <decimal>(row, "REGISTRO", true, 0).ToString();
if (idRegistro != "0")
{
nodoTitolario.IDRegistroAssociato = idRegistro.ToString();
}
string idParent = DataReaderHelper.GetValue <decimal>(row, "IDPARENT", true, 0).ToString();
if (idParent != "0")
{
nodoTitolario.IDParentNodoTitolario = idParent.ToString();
}
nodoTitolario.CodiceLivello = DataReaderHelper.GetValue <string>(row, "CODLIV", false);
nodoTitolario.CountChildNodiTitolario = Int32.Parse(DataReaderHelper.GetValue <decimal>(row, "FIGLIO", false).ToString());
nodoTitolario.NumeroMesiConservazione = Int32.Parse(DataReaderHelper.GetValue <decimal>(row, "NUMMESICONSERVAZIONE", true).ToString());
string idTipoFasc = DataReaderHelper.GetValue <decimal>(row, "ID_TIPO_FASC", true).ToString();
if (idTipoFasc != "0")
{
nodoTitolario.ID_TipoFascicolo = idTipoFasc.ToString();
}
nodoTitolario.bloccaTipoFascicolo = DataReaderHelper.GetValue <string>(row, "CHA_BLOCCA_FASC", true);
string idTitolario = DataReaderHelper.GetValue <decimal>(row, "ID_TITOLARIO", true).ToString();
if (idTitolario != "0")
{
nodoTitolario.ID_Titolario = idTitolario.ToString();
}
nodoTitolario.stato = DataReaderHelper.GetValue <string>(row, "CHA_STATO", true);
DateTime dataAttivazione = DataReaderHelper.GetValue <DateTime>(row, "DTA_ATTIVAZIONE", true);
if (default(DateTime) != dataAttivazione)
{
nodoTitolario.dataAttivazione = dataAttivazione.ToString();
}
DateTime dataCessazione = DataReaderHelper.GetValue <DateTime>(row, "DTA_CESSAZIONE", true);
if (default(DateTime) != dataCessazione)
{
nodoTitolario.dataCessazione = dataCessazione.ToString();
}
nodoTitolario.note = DataReaderHelper.GetValue <string>(row, "VAR_NOTE", true);
return(nodoTitolario);
}
/// <summary>
/// Implementazione della logica del task di migrazione dati
/// per tutti i titolari di una singola amministrazione DocsPa
/// </summary>
/// <param name="infoUtente"></param>
/// <param name="amministrazione"></param>
internal static void ImportaTitolari(InfoUtente infoUtente, InfoAmministrazione amministrazione)
{
using (DocsPaDB.DBProvider dbProvider = new DocsPaDB.DBProvider())
{
// 1. Reperimento titolari per l'amministrazione
using (DataSet ds = new DataSet())
{
if (dbProvider.ExecuteQuery(ds, GetQueryTitolari(infoUtente, amministrazione)))
{
//DocsPaDocumentale_DOCUMENTUM.Documentale.TitolarioManager titolarioManager = new DocsPaDocumentale_DOCUMENTUM.Documentale.TitolarioManager(infoUtente);
foreach (DataRow row in ds.Tables[0].Rows)
{
string codice = DataReaderHelper.GetValue <string>(row, "CODICE", false);
if (codice == CODICE_TITOLARIO)
{
// 2. Import titolario
OrgTitolario titolario = GetTitolario(row, infoUtente, amministrazione);
/*
* if (titolarioManager.SaveTitolario(titolario))
* Log.GetInstance(amministrazione).Write(string.Format("Migrazione titolario. Codice: '{0}' - Descrizione: '{1}'", titolario.Codice, titolario.Descrizione), false);
* else
* // 2a. Errore nell'inserimento del titolario
* throw new ApplicationException(
* string.Format("Si è verificato un errore nell'import del titolario '{0}' per l'amministrazione '{1}'",
* titolario.Codice, amministrazione.Codice));*/
}
else
{
// 3. Import nodo titolario
OrgNodoTitolario nodoTitolario = GetNodoTitolario(row, infoUtente, amministrazione);
/*
* if (titolarioManager.ContainsNodoTitolario(nodoTitolario.ID))
* {
* // Nodo titolario già esistente, save dei dati con refresh delle entries dell'acl associata
* titolarioManager.SaveNodoTitolario(nodoTitolario, true);
*
* Log.GetInstance(amministrazione).Write(string.Format("Migrazione nodo titolario. Codice: '{0}' - Descrizione: '{1}'. Aggiornamento.", nodoTitolario.Codice, nodoTitolario.Descrizione), false);
* }
* else
* {
* if (titolarioManager.SaveNodoTitolario(nodoTitolario))
* Log.GetInstance(amministrazione).Write(string.Format("Migrazione nodo titolario. Codice: '{0}' - Descrizione: '{1}'", nodoTitolario.Codice, nodoTitolario.Descrizione), false);
* else
* // 3a. Errore nell'inserimento del nodo titolario
* throw new ApplicationException(
* string.Format("Si è verificato un errore nell'import del nodo titolario '{0}' per l'amministrazione '{1}'",
* nodoTitolario.Codice, amministrazione.Codice));
* }*/
}
}
}
else
{
// 1a. Errore nel reperimento dei titolari per l'amministrazione
throw new ApplicationException(
string.Format("Si è verificato un errore nel reperimento dei titolari per l'amministrazione '{0}'",
amministrazione.Codice));
}
}
}
}
/// <summary>
/// Aggiornamento visibilità di un ruolo su un nodo di titolario
/// </summary>
/// <param name="nodoTitolario"></param>
/// <param name="ruoloTitolario"></param>
/// <returns></returns>
public bool SetAclRuoloNodoTitolario(OrgNodoTitolario nodoTitolario, OrgRuoloTitolario ruoloTitolario)
{
using (DocsPaDB.Query_DocsPAWS.Amministrazione amm = new DocsPaDB.Query_DocsPAWS.Amministrazione())
return(amm.UpdateRuoloTitolario(nodoTitolario.ID, ruoloTitolario.ID, ruoloTitolario.Associato));
}
/// <summary>
/// Rimozione ACL per il nodo di titolario
/// </summary>
/// <param name="nodoTitolario"></param>
protected virtual void DeleteAclNodoTitolario(OrgNodoTitolario nodoTitolario)
{
CustomServices.AclDefinition aclToRemove = Dfs4DocsPa.getAclDefinition(nodoTitolario.ID, ObjectTypes.NODO_TITOLARIO, nodoTitolario.CodiceAmministrazione);
this.DeleteAcl(aclToRemove);
}
/// <summary>
/// Aggiornamento visibilità di più ruoli su un titolario
/// </summary>
/// <param name="nodoTitolario"></param>
/// <param name="ruoliTitolario"></param>
/// <returns></returns>
public DocsPaVO.amministrazione.EsitoOperazione[] SetAclNodoTitolario(OrgNodoTitolario nodoTitolario, OrgRuoloTitolario[] ruoliTitolario)
{
List <EsitoOperazione> retValue = new List <EsitoOperazione>();
using (DocsPaDB.Query_DocsPAWS.Amministrazione amm = new DocsPaDB.Query_DocsPAWS.Amministrazione())
{
foreach (OrgRuoloTitolario ruolo in ruoliTitolario)
{
bool containsAssociazione = (amm.ContainsAssociazioneRuoloTitolario(nodoTitolario.ID, ruolo.ID));
if (ruolo.Associato && containsAssociazione)
{
// L'associazione tra ruolo e nodo titolario già esiste
retValue.Add(
new EsitoOperazione
{
Codice = Convert.ToInt32(ruolo.ID),
Descrizione = string.Format("Ruolo '{0}' in titolario '{1}':{2}Visibilità già presente", ruolo.Codice, nodoTitolario.Codice, Environment.NewLine)
});
}
else if (!ruolo.Associato && !containsAssociazione)
{
// L'associazione tra ruolo e nodo titolario è già stata rimossa
retValue.Add(
new EsitoOperazione
{
Codice = Convert.ToInt32(ruolo.ID),
Descrizione = string.Format("Ruolo '{0}' in titolario '{1}':{2}Visibilità già rimossa", ruolo.Codice, nodoTitolario.Codice, Environment.NewLine)
});
}
// Aggiornamento della visibilità di ciascun ruolo nel nodo di titolario
else if (!amm.UpdateRuoloTitolario(nodoTitolario.ID, ruolo.ID, ruolo.Associato))
{
// Impostazione della visibilità per il ruolo non è andata a buon fine,
// nell'attributo Codice dell'oggetto "EsitoOperazione" viene impostato
// l'id del ruolo per cui si è verificato l'errore
retValue.Add(
new EsitoOperazione
{
Codice = Convert.ToInt32(ruolo.ID),
Descrizione = string.Format("Ruolo '{0}' in titolario '{1}':{2}Aggiornamento visibilità non andato a buon fine", ruolo.Codice, nodoTitolario.Codice, Environment.NewLine)
});
}
else
{
// Impostazione della visibilità per il ruolo completata con successo
string operazione = string.Empty;
if (ruolo.Associato)
{
operazione = "impostata";
}
else
{
operazione = "rimossa";
}
retValue.Add(
new EsitoOperazione
{
Codice = 0,
Descrizione = string.Format("Ruolo '{0}' in titolario '{1}':{2}Visibilità {3} correttamente", ruolo.Codice, nodoTitolario.Codice, Environment.NewLine, operazione)
});
}
}
}
return(retValue.ToArray());
}
/// <summary>
///
/// </summary>
/// <param name="nodoTitolario"></param>
/// <param name="refreshAclIfUpdate">
/// Se true, indica di aggiornare le entries dell'ACL associata al nodo titolario
/// </param>
/// <returns></returns>
public bool SaveNodoTitolario(OrgNodoTitolario nodoTitolario, bool refreshAclIfUpdate)
{
bool retValue = false;
bool aclCreated = false;
try
{
//titolario.ID viene SEMPRE valorizzato da ETDOCS; se così non è --> ERRORE
if (string.IsNullOrEmpty(nodoTitolario.ID))
{
retValue = false;
logger.Debug("Errore passaggio dati da ETDOCS: ID nodo titolario mancante");
}
else
{
IQueryService querySrvc = this.GetQueryServiceInstance();
DataObject dataObject = new DataObject();
dataObject.Type = ObjectTypes.NODO_TITOLARIO;
DataObject dataObjectFascicoloGenerale = null;
// Reperimento oggetto identity per il titolario corrente
ObjectIdentity nodoTitolarioIdentity = Dfs4DocsPa.getNodoTitolarioIdentity(nodoTitolario.ID);
// Verifica esistenza nodo titolario
bool insertMode = (!Dfs4DocsPa.containsNodoTitolario(nodoTitolario.ID, querySrvc));
IObjectService objSrvc = this.GetObjectServiceInstance();
if (insertMode)
{
// Modalità di inserimento
// Creazione oggetto identity per nuovo inserimento
dataObject.Identity = new ObjectIdentity(DctmConfigurations.GetRepositoryName());
// Determinazione dell'oggetto parent del nodo di titolario da inserire
ObjectIdentity parentIdentity = null;
if (nodoTitolario.Livello == "1")
{
// Se nodo di primo livello, deve essere legato alla struttura di titolario
parentIdentity = Dfs4DocsPa.getTitolarioIdentity(nodoTitolario.ID_Titolario);
}
else
{
// Se nodo figlio di un altro nodo, lo lega al padre
parentIdentity = Dfs4DocsPa.getNodoTitolarioIdentity(nodoTitolario.IDParentNodoTitolario);
}
dataObject.Relationships = new List <Relationship>();
dataObject.Relationships.Add(DfsHelper.createParentFolderRelationship(parentIdentity));
// Creazione fascicolo generale, figlio nodo del titolario da creare
dataObjectFascicoloGenerale = new DataObject();
dataObjectFascicoloGenerale.Type = ObjectTypes.FASCICOLO_GENERALE;
dataObjectFascicoloGenerale.Identity = new ObjectIdentity(DctmConfigurations.GetRepositoryName());
// Creazione oggetto relationship
dataObjectFascicoloGenerale.Relationships = new List <Relationship>();
dataObjectFascicoloGenerale.Relationships.Add(DfsHelper.createParentFolderRelationship(nodoTitolarioIdentity));
dataObjectFascicoloGenerale.Properties = new PropertySet();
dataObjectFascicoloGenerale.Properties.Properties.AddRange(Dfs4DocsPa.getFascicoloGeneraleProperties(nodoTitolario));
}
else
{
// Modalità di aggiornamento
// Reperimento oggetto identity per nodo titolario da modificare
dataObject.Identity = nodoTitolarioIdentity;
}
// Impostazione proprietà nodo titolario
dataObject.Properties = new PropertySet();
dataObject.Properties.Properties.AddRange(Dfs4DocsPa.getNodoTitolarioProperties(nodoTitolario));
List <DataObject> dataObjectList = new List <DataObject>();
dataObjectList.Add(dataObject);
if (dataObjectFascicoloGenerale != null)
{
// Inserimento DataObject relativo al fascicolo generale
dataObjectList.Add(dataObjectFascicoloGenerale);
}
// Creazione oggetto DataPackage
DataPackage dataPackage = new DataPackage();
dataPackage.DataObjects.AddRange(dataObjectList);
dataPackage.RepositoryName = DctmConfigurations.GetRepositoryName();
// Save oggetto nodo titolario in documentum
if (insertMode)
{
// Creazione ACL, comune sia per il nodo titolario che per il fascicolo generale in esso contenuto
CustomServices.AclDefinition aclDefinition = this.CreateAclNodoTitolario(nodoTitolario);
// ACL del titolario creata
aclCreated = true;
// Impostazione delle properties relative all'acl per il nodo titolario
AclHelper.setAclObjectProperties(dataObject.Properties, aclDefinition);
// Impostazione delle properties relative all'acl per il fascicolo generale
AclHelper.setAclObjectProperties(dataObjectFascicoloGenerale.Properties, aclDefinition);
dataPackage = objSrvc.Create(dataPackage, null);
}
else
{
dataPackage = objSrvc.Update(dataPackage, null);
if (refreshAclIfUpdate)
{
// Aggiornamento delle entries dell'acl associata al nodo
this.RefreshAclNodoTitolario(nodoTitolario);
}
}
retValue = (dataPackage.DataObjects.Count > 0);
if (retValue)
{
logger.Debug(string.Format("Documentum.SaveNodoTitolario: salvato nodo di titolario con id {0}", nodoTitolario.ID));
}
}
}
catch (Exception ex)
{
retValue = false;
logger.Debug("Errore in Documentum.SaveNodoTitolario: " + ex.ToString());
if (aclCreated)
{
// Se l'ACL è stata creata, viene rimossa
this.DeleteAclNodoTitolario(nodoTitolario);
}
}
return(retValue);
}
/// <summary>
/// Aggiornamento metadati del nodo di titolario
/// </summary>
/// <param name="nodoTitolario"></param>
/// <returns></returns>
public bool SaveNodoTitolario(OrgNodoTitolario nodoTitolario)
{
return(this.SaveNodoTitolario(nodoTitolario, false));
}