/// <summary> /// Creazione delle ACL per il fascicolo /// NOTA: RW di DocsPA equivale a DELETE di Documentum /// </summary> /// <param name="fascicolo"></param> /// <param name="ruoloCreatore"></param> /// <returns>ACL creata, ma ancora non associata al documento</returns> protected virtual CustomServices.AclDefinition CreateAclFascicolo(DocsPaVO.fascicolazione.Fascicolo fascicolo, DocsPaVO.utente.Ruolo ruoloCreatore) { CustomServices.AclDefinition aclData = null; try { // Reperimento ACL per il fascicolo aclData = Dfs4DocsPa.getAclDefinition(fascicolo.systemID, ObjectTypes.FASCICOLO, this.InfoUtente); // istanziamo ACLservice in modalità super-user per poter comunque creare una acl di sistema // nota: questo non sarebbe strettamente necessario (si potrebbe usare una user-acl, di tipo public) // ma si ritiene che non sia bello avere le acl di proprietà degli utenti creatori del documento CustomServices.IAclService aclSvcSuper = DctmServiceFactory.GetCustomServiceInstance <CustomServices.IAclService>(UserManager.ImpersonateSuperUser()); CustomServices.ObjectIdentity aclIdentity = aclSvcSuper.Create(aclData); if (aclIdentity == null) { throw new ApplicationException(string.Concat("Errore nella creazione dell'ACL per il fascicolo con id '{0}'", fascicolo.systemID)); } } catch (Exception ex) { string errorMessage = string.Format("Errore in Documentum.CreateAclFascicolo:\n{0}", ex.ToString()); logger.Debug(errorMessage); throw new ApplicationException(errorMessage); } return(aclData); }
/// <summary> /// Creazione delle ACL per il nodo titolario /// </summary> /// <param name="nodoTitolario"></param> /// <returns>ACL creata, ma ancora non associata al nodo titolario</returns> protected virtual CustomServices.AclDefinition CreateAclNodoTitolario(DocsPaVO.amministrazione.OrgNodoTitolario nodoTitolario) { CustomServices.AclDefinition aclData = null; try { // Reperimento ACL nodo titolario aclData = Dfs4DocsPa.getAclDefinition(nodoTitolario.ID, ObjectTypes.NODO_TITOLARIO, nodoTitolario.CodiceAmministrazione); 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 il nodo titolario con ID '{0}'", nodoTitolario.ID)); } } catch (Exception ex) { string errorMessage = string.Format("Errore in Documentum.CreateAclNodoTitolario:\n{0}", ex.ToString()); logger.Debug(errorMessage); throw new ApplicationException(errorMessage); } return(aclData); }
/// <summary> /// Impostazione della visibilità su un fascicolo /// (e dell'ownership, nel caso l'utente / ruolo rimosso fosse il proprietario) /// </summary> /// <param name="infoDiritto"></param> /// <returns></returns> public bool AddPermission(DocsPaVO.fascicolazione.DirittoOggetto infoDiritto) { bool added = false; // se si revocano i diritti all'utente proprietario, // si revocano anche al ruolo proprietario e viceversa. // Il proprietario del documento diventa l'utente e il ruolo del revocante try { // Reperimento utente proprietario string ownerUser = TypeUtente.NormalizeUserName(DocsPaQueryHelper.getCodiceRubricaProprietario(infoDiritto.idObj, true)); // Modifica ownership del fascicolo if (this.SetOwnershipFascicolo(infoDiritto.idObj, ownerUser)) { CustomServices.AclDefinition aclDefinition = Dfs4DocsPa.getAclDefinition(infoDiritto.idObj, ObjectTypes.FASCICOLO, this.InfoUtente); CustomServices.IAclService aclService = DctmServiceFactory.GetCustomServiceInstance <CustomServices.IAclService>(UserManager.ImpersonateSuperUser()); aclService.ClearAndGrant(aclDefinition, infoDiritto.idObj); added = true; } } catch (Exception ex) { added = false; logger.Debug(string.Format("Errore in Documentum.RemovePermission:\n{0}", ex.ToString())); } return(added); }
/// <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> /// Revoca della visibilità su un documento (e dell'ownership, nel caso l'utente / ruolo rimosso è proprietario) /// </summary> /// <param name="documentInfo"></param> /// <returns></returns> public bool RemovePermission(DocsPaVO.fascicolazione.DirittoOggetto infoDiritto) { bool removed = false; try { // Reperimento utente proprietario string ownerUser = TypeUtente.NormalizeUserName(DocsPaQueryHelper.getCodiceRubricaProprietario(infoDiritto.idObj, true)); if (this.SetOwnershipFascicolo(infoDiritto.idObj, ownerUser)) { CustomServices.AclDefinition aclDefinition = Dfs4DocsPa.getAclDefinition(infoDiritto.idObj, ObjectTypes.FASCICOLO, this.InfoUtente); CustomServices.IAclService aclService = DctmServiceFactory.GetCustomServiceInstance <CustomServices.IAclService>(UserManager.ImpersonateSuperUser()); aclService.ClearAndGrant(aclDefinition, infoDiritto.idObj); } removed = true; } catch (Exception ex) { removed = false; logger.Debug(string.Format("Errore in Documentum.RemovePermission:\n{0}", ex.ToString())); } return(removed); }
/// <summary> /// /// </summary> /// <param name="aclToRemove"></param> protected virtual void DeleteAcl(CustomServices.AclDefinition aclToRemove) { // Creazione servizio ACL CustomServices.IAclService aclService = DctmServiceFactory.GetCustomServiceInstance <CustomServices.IAclService>(UserManager.ImpersonateSuperUser()); aclService.Delete(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) { // 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> /// /// </summary> /// <param name="titolario"></param> protected void ClearAclFascicoliTitolario(OrgTitolario titolario) { foreach (string idFascicolo in DocsPaQueryHelper.getFascicoliProcedimentaliTitolario(titolario.ID)) { // Reperimento e cancellazione ACL per il fascicolo procedimentale CustomServices.AclDefinition aclDefinition = Dfs4DocsPa.getAclDefinition(idFascicolo, ObjectTypes.FASCICOLO, this.InfoUtente); this.DeleteAcl(aclDefinition); } }
/// <summary> /// Handler dell'evento di avvenuta accettazione / rifiuto di una trasmissione di un documento / fascicolo /// </summary> /// <param name="trasmissione"></param> /// <param name="ruolo"></param> /// <param name="tipoRisposta"></param> public void TrasmissioneAccettataRifiutataEventHandler(DocsPaVO.trasmissione.Trasmissione trasmissione, DocsPaVO.utente.Ruolo ruolo, DocsPaVO.trasmissione.TipoRisposta tipoRisposta) { CustomServices.AclDefinition aclData = null; DateTime startDate = DateTime.Now; // Aggiornamento ACL in DCTM, con le credenziali di superuser CustomServices.IAclService aclService = DctmServiceFactory.GetCustomServiceInstance <CustomServices.IAclService>(UserManager.ImpersonateSuperUser()); if (trasmissione.tipoOggetto == DocsPaVO.trasmissione.TipoOggetto.DOCUMENTO) { // Reperimento della lista delle ACL aggiornata nella tabella security di docspa aclData = Dfs4DocsPa.getAclDefinition(trasmissione.infoDocumento.docNumber, DocsPaObjectTypes.ObjectTypes.DOCUMENTO, this.InfoUtente); aclService.ClearAndGrant(aclData, trasmissione.infoDocumento.idProfile); } else if (trasmissione.tipoOggetto == DocsPaVO.trasmissione.TipoOggetto.FASCICOLO) { DateTime startDateFasc = DateTime.Now; // Reperimento della lista delle ACL aggiornata nella tabella security di docspa aclData = Dfs4DocsPa.getAclDefinition(trasmissione.infoFascicolo.idFascicolo, DocsPaObjectTypes.ObjectTypes.FASCICOLO, this.InfoUtente); aclService.ClearAndGrant(aclData, trasmissione.infoFascicolo.idFascicolo); logger.Debug("Tot sec. FASC: " + DateTime.Now.Subtract(startDateFasc).TotalSeconds.ToString()); string[] idProfiles = DocsPaQueryHelper.getDocumentiInFascicolo(trasmissione.infoFascicolo.idFascicolo); //PORKING: nonè necessario farlo ora, perchè le aCL di Documenti vengono rimappate se necesario quando gli utenti o i ruoli faranno // GetDettaglio con il metedo RefreshAcl if (idProfiles != null && idProfiles.Length < 20) { foreach (string idProfile in idProfiles) { DateTime startDateDoc = DateTime.Now; // Aggiornamento delle ACL per tutti i documenti nel fascicolo (compresi eventuali sottofascicoli) // Aggiornamento delle ACL per tutti i documenti nel fascicolo (compresi eventuali sottofascicoli) //DCTM è usato solo con PITRE e in PITRE storicamente il idprofile è sempre uguale a docnumber quindi posso togliere questa query //DocsPaQueryHelper.getDocNumber(idProfile) è passare in input direttamente idProfile al metodo getAclDefinition aclData = Dfs4DocsPa.getAclDefinition(idProfile, DocsPaObjectTypes.ObjectTypes.DOCUMENTO, this.InfoUtente); aclService.ClearAndGrant(aclData, idProfile); logger.DebugFormat("Tot sec. DOC_{0}: {1}", idProfile, DateTime.Now.Subtract(startDateDoc).TotalSeconds.ToString()); } } } logger.Debug("Tot sec.: " + DateTime.Now.Subtract(startDate).TotalSeconds.ToString()); }
/// <summary> /// Aggiornamento delle entries dell'acl associata al nodo di titolario /// </summary> /// <param name="nodoTitolario"></param> /// <returns></returns> protected virtual void RefreshAclNodoTitolario(DocsPaVO.amministrazione.OrgNodoTitolario nodoTitolario) { try { // Reperimento ACL nodo titolario CustomServices.AclDefinition aclData = Dfs4DocsPa.getAclDefinition(nodoTitolario.ID, ObjectTypes.NODO_TITOLARIO, nodoTitolario.CodiceAmministrazione); CustomServices.IAclService aclService = DctmServiceFactory.GetCustomServiceInstance <CustomServices.IAclService>(UserManager.ImpersonateSuperUser()); aclService.ClearAndGrant(aclData); } catch (Exception ex) { string errorMessage = string.Format("Errore in Documentum.CreateAclNodoTitolario:\n{0}", ex.ToString()); logger.Debug(errorMessage); throw new ApplicationException(errorMessage); } }
/// <summary> /// Reperimento ACL associate al sottofascicolo /// </summary> /// <param name="folder"></param> /// <returns></returns> protected virtual CustomServices.AclDefinition GetAclDefinitionSottoFascicolo(DocsPaVO.fascicolazione.Folder folder) { // Reperimento ACL del fascicolo di appartenenza e associazione al sottofascicolo CustomServices.AclDefinition aclDefinition = null; if (DocsPaQueryHelper.isFascicoloGenerale(folder.idFascicolo)) { // Determina se il fascicolo in cui si sta inserendo il folder è un fascicolo generale; // in tal caso l'acl da assegnare è la stessa del nodo titolario di appartenenza string idNodoTitolario = DocsPaQueryHelper.getIdNodoTitolario(folder.idFascicolo); aclDefinition = Dfs4DocsPa.getAclDefinition(idNodoTitolario, ObjectTypes.NODO_TITOLARIO, this.InfoUtente); } else { // Nel caso di inserimento di un folder in un fascicolo procedimentale, // l'acl del folder sarà quella del fascicolo di appartenenza aclDefinition = Dfs4DocsPa.getAclDefinition(folder.idFascicolo, ObjectTypes.FASCICOLO, this.InfoUtente); } return(aclDefinition); }
/// <summary> /// Aggiornamento delle entries dell'acl del fascicolo /// </summary> /// <param name="fascicolo"></param> protected virtual void RefreshAclFascicolo(DocsPaVO.fascicolazione.Fascicolo fascicolo) { try { // Reperimento ACL per il fascicolo CustomServices.AclDefinition aclData = Dfs4DocsPa.getAclDefinition(fascicolo.systemID, ObjectTypes.FASCICOLO, this.InfoUtente); // istanziamo ACLservice in modalità super-user per poter comunque creare una acl di sistema // nota: questo non sarebbe strettamente necessario (si potrebbe usare una user-acl, di tipo public) // ma si ritiene che non sia bello avere le acl di proprietà degli utenti creatori del documento CustomServices.IAclService aclSvcSuper = DctmServiceFactory.GetCustomServiceInstance <CustomServices.IAclService>(UserManager.ImpersonateSuperUser()); aclSvcSuper.ClearAndGrant(aclData, fascicolo.systemID); } catch (Exception ex) { string errorMessage = string.Format("Errore in Documentum.RefreshAclFascicolo:\n{0}", ex.ToString()); logger.Debug(errorMessage); throw new ApplicationException(errorMessage); } }
/// <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); }
/// <summary> /// Aggiornamento Acl per il documento /// </summary> /// <param name="idProfile"></param> protected virtual CustomServices.AclDefinition UpdateAclDocumento(string idProfile, string docNumber) { bool stamparegistro = DocsPaQueryHelper.isStampaRegistro(docNumber) && !DocsPaQueryHelper.isStampaRegistroRepertorio(docNumber); CustomServices.AclDefinition aclData = null; if (stamparegistro) { aclData = Dfs4DocsPa.getAclDefinition(idProfile, ObjectTypes.DOCUMENTO_STAMPA_REGISTRO, this.InfoUtente); } else { aclData = Dfs4DocsPa.getAclDefinition(idProfile, ObjectTypes.DOCUMENTO, this.InfoUtente); } // istanziamo ACLservice in modalità super-user per poter comunque creare una acl di sistema // nota: questo non sarebbe strettamente necessario (si potrebbe usare una user-acl, di tipo public) // ma si ritiene che non sia bello avere le acl di proprietà degli utenti creatori del documento CustomServices.IAclService aclSvcSuper = DctmServiceFactory.GetCustomServiceInstance <CustomServices.IAclService>(UserManager.ImpersonateSuperUser()); // Aggiornamento ACL aclSvcSuper.ClearAndGrant(aclData, idProfile); return(aclData); }
/// <summary> /// Handler dell'evento di avvenuto smistamento di un documento ad un ruolo /// </summary> /// <param name="mittente"></param> /// <param name="documento"></param> /// <param name="ruolo"></param> /// <param name="accessRights"></param> public void SmistamentoDocumentoCompletatoEventHandler(DocsPaVO.Smistamento.MittenteSmistamento mittente, DocsPaVO.Smistamento.DocumentoSmistamento documento, DocsPaVO.Smistamento.RuoloSmistamento ruolo, string accessRights) { //// Reperimento ACL per il documento smistato //CustomServices.AclDefinition aclDefinition = AclHelper.getAclDefinition(DocsPaQueryHelper.getCodiceAmministrazione(this.InfoUtente.idAmministrazione), documento.DocNumber, DocsPaObjectTypes.ObjectTypes.DOCUMENTO); //// Inserimento dell'entry relativa al ruolo destinatario //List<CustomServices.AclEntry> entries = new List<CustomServices.AclEntry>(aclDefinition.entries); //AclHelper.addBasicPermit(entries, DocsPaObjectTypes.TypeGruppo.NormalizeGroupName(ruolo.Codice), Dfs4DocsPa.getPermitLevel(accessRights)); //aclDefinition.entries = entries.ToArray(); //// Aggiornamento ACL in DCTM, con le credenziali di superuser //CustomServices.IAclService aclService = DctmServiceFactory.GetCustomServiceInstance<CustomServices.IAclService>(UserManager.ImpersonateSuperUser()); //aclService.Clear(aclDefinition); //aclService.UpdateWithGrant(aclDefinition); CustomServices.AclDefinition aclData = null; // Reperimento della lista delle ACL aggiornata nella tabella security di docspa aclData = Dfs4DocsPa.getAclDefinition(documento.DocNumber, DocsPaObjectTypes.ObjectTypes.DOCUMENTO, this.InfoUtente); // Aggiornamento ACL in DCTM, con le credenziali di superuser CustomServices.IAclService aclService = DctmServiceFactory.GetCustomServiceInstance <CustomServices.IAclService>(UserManager.ImpersonateSuperUser()); aclService.ClearAndGrant(aclData, documento.IDDocumento); }
/// <summary> /// Rimozione dell'ACL per gli oggetti visibili da tutta l'amministrazione /// </summary> /// <param name="aclAdmin"></param> protected virtual void DeleteAclAdmin(CustomServices.AclDefinition aclAdmin) { // Creazione servizio ACL (con credenziali da superamministratore) CustomServices.IAclService aclService = DctmServiceFactory.GetCustomServiceInstance <CustomServices.IAclService>(UserManager.ImpersonateSuperUser()); aclService.Delete(aclAdmin); }
/// <summary> /// Creazione di un nuovo fascicolo in DCTM /// </summary> /// <remarks> /// /// PreCondizioni: /// Il fascicolo è stato inserito correttamente in DocsPa /// ed è stato generato un'identificativo univoco /// /// PostCondizioni: /// Creato un oggetto in Documentum corrispondente all'oggetto /// fascicolo di DocsPa. L'oggetto avrà i metadati del fascicolo /// per la sola consultazione in documentum. /// /// </remarks> /// <param name="classifica"></param> /// <param name="fascicolo"></param> /// <param name="ruolo"></param> /// <param name="enableUfficioReferente"></param> /// <returns></returns> public bool CreateProject(Classificazione classifica, Fascicolo fascicolo, Ruolo ruolo, bool enableUfficioReferente, out ResultCreazioneFascicolo result) { logger.Info("BEGIN"); bool retValue = false; result = ResultCreazioneFascicolo.GENERIC_ERROR; CustomServices.AclDefinition aclFascicolo = null; try { //fascicolo.systemID viene SEMPRE valorizzato da ETDOCS; se così non è --> ERRORE if (string.IsNullOrEmpty(fascicolo.systemID)) { logger.Debug("Errore passaggio dati da ETDOCS."); } else { // Reperimento dell'objectidentity relativo al nodo titolario in cui andrà inserito il fascicolo ObjectIdentity nodoTitolarioIdentity = Dfs4DocsPa.getNodoTitolarioIdentity(fascicolo.idClassificazione); // Reperimento properties del fascicolo procedimentale PropertySet props = new PropertySet(); props.Properties.AddRange(Dfs4DocsPa.getFascicoloProcedimentaleProperties(fascicolo)); // Creazione delle ACL per il fascicolo aclFascicolo = this.CreateAclFascicolo(fascicolo, ruolo); // Associazione delle ACL al fascicolo da creare AclHelper.setAclObjectProperties(props, aclFascicolo); ObjectIdentity identity = new ObjectIdentity(DctmConfigurations.GetRepositoryName()); DataObject dataObject = new DataObject(identity, ObjectTypes.FASCICOLO_PROCEDIMENTALE); dataObject.Properties = props; dataObject.Relationships.Add(DfsHelper.createParentFolderRelationship(nodoTitolarioIdentity)); DataPackage dataPackage = new DataPackage(dataObject); IObjectService objectService = this.GetServiceInstance <IObjectService>(false); dataPackage = objectService.Create(dataPackage, null); retValue = (dataPackage.DataObjects.Count == 1); if (retValue) { result = ResultCreazioneFascicolo.OK; logger.Debug(string.Format("Documentum.CreateProject: creato fascicolo con id {0}", fascicolo.systemID)); } } } catch (Exception ex) { retValue = false; result = ResultCreazioneFascicolo.GENERIC_ERROR; logger.Debug(string.Format("Errore in Documentum.CreateProject:\n{0}", ex.ToString())); if (aclFascicolo != null) { // Rimozione ACL fascicolo in caso di errore this.DeleteAcl(aclFascicolo); } } logger.Info("END"); return(retValue); }
/// <summary> /// Creazione nuovo sottofascicolo /// </summary> /// <param name="folder"></param> /// <param name="ruolo"></param> /// <param name="result"></param> /// <param name="ruoliSuperiori"> /// Ruoli superiori cui è impostata la visibilità del sottofascicolo /// </param> /// <returns></returns> public bool CreateFolder(DocsPaVO.fascicolazione.Folder folder, DocsPaVO.utente.Ruolo ruolo, out DocsPaVO.fascicolazione.ResultCreazioneFolder result, out DocsPaVO.utente.Ruolo[] ruoliSuperiori) { bool retValue = false; result = ResultCreazioneFolder.GENERIC_ERROR; ruoliSuperiori = null; try { // Recuperare l'ID del padre del folder: dato che la modalità è diversa se il padre // è Fascicolo o Sottofascicolo, è necessario verificare la casistica // Caso in cui il parent del sottofascicolo è un sottofascicolo stesso Qualification qualSottoFascicoloParent = Dfs4DocsPa.getSottofascicoloQualificationById(folder.idParent); string parentId = DfsHelper.getDctmObjectId(this.GetServiceInstance <IQueryService>(false), qualSottoFascicoloParent); if (string.IsNullOrEmpty(parentId)) { // Caso in cui il parent del sottofascicolo è un fascicolo stesso qualSottoFascicoloParent = Dfs4DocsPa.getFascicoloQualificationById(folder.idFascicolo); parentId = DfsHelper.getDctmObjectId(this.GetServiceInstance <IQueryService>(false), qualSottoFascicoloParent); } if (!string.IsNullOrEmpty(parentId)) { ObjectIdentity parentIdentity = new ObjectIdentity(new ObjectId(parentId), DctmConfigurations.GetRepositoryName()); ObjectIdentity identity = new ObjectIdentity(DctmConfigurations.GetRepositoryName()); DataObject dataObject = new DataObject(identity, ObjectTypes.SOTTOFASCICOLO); dataObject.Properties.Properties.AddRange(Dfs4DocsPa.getSottoFascicoloProperties(folder)); dataObject.Relationships.Add(DfsHelper.createParentFolderRelationship(parentIdentity)); // Reperimento ACL del fascicolo di appartenenza e associazione al sottofascicolo CustomServices.AclDefinition aclDefinition = this.GetAclDefinitionSottoFascicolo(folder); AclHelper.setAclObjectProperties(dataObject.Properties, aclDefinition); DataPackage dataPackage = new DataPackage(dataObject); dataPackage = this.GetServiceInstance <IObjectService>(false).Create(dataPackage, null); retValue = (dataPackage.DataObjects.Count == 1); if (retValue) { result = ResultCreazioneFolder.OK; logger.Debug(string.Format("Documentum.CreateFolder: creato sottofascicolo con id {0}", folder.systemID)); } } else { throw new ApplicationException(string.Format("Non è stato possibile reperire l'oggetto parent per il folder con id '{0}'", folder.systemID)); } } catch (Exception ex) { retValue = false; logger.Debug(string.Format("Errore in Documentum.CreateFolder:\n{0}", ex.ToString())); } return(retValue); }
/// <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> /// Handler dell'evento di avvenuta trasmissione di un documento / fascicolo /// </summary> /// <param name="trasmissione"></param> /// <param name="infoSecurity"> /// Oggetto contenente i metadati relativi alla tipologia di ACL /// impostata nella trasmissione di un documento / fascicolo /// </param> public void TrasmissioneCompletataEventHandler(DocsPaVO.trasmissione.Trasmissione trasmissione, DocsPaVO.trasmissione.infoSecurity[] infoSecurityList) { // In caso di trasmissione con cessione diritti, // viene modificata l'ownership del documento / fascicolo trasmesso // se il documento era di proprietà del cedente if (trasmissione.cessione != null && trasmissione.cessione.docCeduto) { // imposta l'Ownership solo se è stato impostato il nuovo utente che diventerà proprietario del doc/fas. // Questo avviene quando si stanno cedendo i diritti di proprietà (P). // Se si stanno cedendo i diritti acquisiti (A o T o F) questo blocco viene saltato. if (trasmissione.cessione.idPeopleNewPropr != null && trasmissione.cessione.idPeopleNewPropr != "") { IQueryService queryService = DctmServiceFactory.GetServiceInstance <IQueryService>(UserManager.ImpersonateSuperUser()); // Reperimento nome utente e ruolo cui viene impostata l'ownership del documento string ownerUser = DocsPaObjectTypes.TypeUtente.NormalizeUserName(DocsPaQueryHelper.getCodiceUtente(trasmissione.cessione.idPeopleNewPropr)); if (trasmissione.tipoOggetto == DocsPaVO.trasmissione.TipoOggetto.DOCUMENTO) { string ownerRole = DocsPaObjectTypes.TypeGruppo.NormalizeGroupName(DocsPaQueryHelper.getCodiceRuoloFromIdGroups(trasmissione.cessione.idRuoloNewPropr)); Dfs4DocsPa.setOwnershipDocumento(trasmissione.infoDocumento.idProfile, ownerUser, ownerRole, queryService); } else if (trasmissione.tipoOggetto == DocsPaVO.trasmissione.TipoOggetto.FASCICOLO) { Dfs4DocsPa.setOwnershipFascicolo(trasmissione.infoFascicolo.idFascicolo, ownerUser, queryService); } } } CustomServices.AclDefinition aclData = null; if (trasmissione.tipoOggetto == DocsPaVO.trasmissione.TipoOggetto.DOCUMENTO) { // Reperimento della lista delle ACL aggiornata nella tabella security di docspa aclData = Dfs4DocsPa.getAclDefinition(trasmissione.infoDocumento.docNumber, DocsPaObjectTypes.ObjectTypes.DOCUMENTO, this.InfoUtente); // Aggiornamento ACL in DCTM, con le credenziali di superuser CustomServices.IAclService aclService = DctmServiceFactory.GetCustomServiceInstance <CustomServices.IAclService>(UserManager.ImpersonateSuperUser()); aclService.ClearAndGrant(aclData, trasmissione.infoDocumento.idProfile); } else if (trasmissione.tipoOggetto == DocsPaVO.trasmissione.TipoOggetto.FASCICOLO) { // Reperimento della lista delle ACL aggiornata nella tabella security di docspa aclData = Dfs4DocsPa.getAclDefinition(trasmissione.infoFascicolo.idFascicolo, DocsPaObjectTypes.ObjectTypes.FASCICOLO, this.InfoUtente); // Aggiornamento ACL in DCTM, con le credenziali di superuser CustomServices.IAclService aclService = DctmServiceFactory.GetCustomServiceInstance <CustomServices.IAclService>(UserManager.ImpersonateSuperUser()); aclService.ClearAndGrant(aclData, trasmissione.infoFascicolo.idFascicolo); string[] idProfiles = DocsPaQueryHelper.getDocumentiInFascicolo(trasmissione.infoFascicolo.idFascicolo); //PORKING: nonè necessario farlo ora, perchè le aCL di Documenti vengono rimappate se necesario quando gli utenti o i ruoli faranno // GetDettaglio con il metedo RefreshAcl if (idProfiles != null && idProfiles.Length < 20) { foreach (string idProfile in idProfiles) { // Aggiornamento delle ACL per tutti i documenti nel fascicolo (compresi eventuali sottofascicoli) //DCTM è usato solo con PITRE e in PITRE storicamente il idprofile è sempre uguale a docnumber quindi posso togliere questa query //DocsPaQueryHelper.getDocNumber(idProfile) è passare in input direttamente idProfile al metodo getAclDefinition aclData = Dfs4DocsPa.getAclDefinition(idProfile, DocsPaObjectTypes.ObjectTypes.DOCUMENTO, this.InfoUtente); aclService.ClearAndGrant(aclData, idProfile); } } } }
/// <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> /// 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> /// Inserimento o aggiornamento dei metadati generali relativi /// all’intera struttura di classificazione dei documenti /// </summary> /// <param name="titolario"></param> /// <returns></returns> public bool SaveTitolario(OrgTitolario titolario) { bool retValue = false; try { //titolario.ID viene SEMPRE valorizzato da ETDOCS; se così non è --> ERRORE if (string.IsNullOrEmpty(titolario.ID)) { logger.Debug("Errore passaggio dati da ETDOCS: ID Titolario mancante"); } else { // Reperimento istanza objectservice IObjectService objSrvc = GetObjectServiceInstance(); DataObject dataObject = new DataObject(); dataObject.Type = ObjectTypes.TITOLARIO; // Reperimento oggetto identity per il titolario corrente ObjectIdentity titolarioIdentity = Dfs4DocsPa.getTitolarioIdentity(titolario.ID); IQueryService querySrvc = this.GetQueryServiceInstance(); // Verifica se il titolario è già esistente bool insertMode = (!Dfs4DocsPa.containsTitolario(titolario.ID, querySrvc)); if (insertMode) { // Creazione oggetto identity per nuovo inserimento dataObject.Identity = new ObjectIdentity(DctmConfigurations.GetRepositoryName()); // Modalità di in inserimento, creazione oggetto Identity parent e oggetto relationship ObjectIdentity parentIdentity = DfsHelper.createObjectIdentityByPath(DocsPaAdminCabinet.getRootTitolario(titolario.CodiceAmministrazione)); dataObject.Relationships = new List <Relationship>(); dataObject.Relationships.Add(DfsHelper.createParentFolderRelationship(parentIdentity)); } else { // Reperimento oggetto identity per titolario da modificare dataObject.Identity = titolarioIdentity; } // Impostazione proprietà titolario dataObject.Properties = new PropertySet(); dataObject.Properties.Properties.AddRange(Dfs4DocsPa.getTitolarioProperties(titolario)); DataPackage dataPackage = new DataPackage(dataObject); dataPackage.RepositoryName = DctmConfigurations.GetRepositoryName(); // Save oggetto titolario in documentum if (insertMode) { // Reperimento ACL dell'amministrazione da associare al titolario CustomServices.AclDefinition aclDefinition = Dfs4DocsPa.getAclDefinitionAmministrazione(titolario.CodiceAmministrazione); // Impostazione delle properties relative all'acl per il nodo titolario AclHelper.setAclObjectProperties(dataObject.Properties, aclDefinition); dataPackage = objSrvc.Create(dataPackage, null); } else { dataPackage = objSrvc.Update(dataPackage, null); } retValue = (dataPackage.DataObjects.Count > 0); if (retValue) { logger.Debug(string.Format("Documentum.SaveTitolario: salvato titolario con id {0}", titolario.ID)); } } } catch (Exception ex) { retValue = false; logger.Debug("Errore in Documentum.SaveTitolario: " + ex.ToString()); } return(retValue); }