/// <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="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> /// 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> /// 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> /// 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> /// 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> /// Verifica credenziali utente /// </summary> /// <param name="userName"></param> protected virtual bool VerifyCredentials(string userName, string authenticationToken, out DocsPaVO.utente.UserLogin.LoginResult loginResult) { bool retValue = false; loginResult = UserLogin.LoginResult.APPLICATION_ERROR; try { ObjectIdentity identity = Dfs4DocsPa.getUserHomeFolderIdentity(userName); IObjectService objectService = DctmServiceFactory.GetServiceInstance <IObjectService>(authenticationToken); logger.Debug("Inizio richiamo authenticationToken"); DataPackage dataPackage = objectService.Get(new ObjectIdentitySet(identity), null); logger.Debug("Fine chiamata authenticationToken"); retValue = (dataPackage != null); } /* * catch (Emc.Documentum.FS.Runtime.AuthenticationException exAuth) * { * //AuthenticationException - Exception in com.emc.documentum.fs.rt * //Exception which is raised when authentication errors occur * loginResult = DocsPaVO.utente.UserLogin.LoginResult.UNKNOWN_DTCM_USER; * retValue = false; * * logger.Debug(string.Format("Credenziali utente DTCM non valide: '{0}'", userName)); * } */ catch (Emc.Documentum.FS.Runtime.ServiceInvocationException exServiceInvocation) { //AuthenticationException - Exception in com.emc.documentum.fs.rt //Exception which is raised when authentication errors occur loginResult = DocsPaVO.utente.UserLogin.LoginResult.DTCM_SERVICE_NO_CONTACT; retValue = false; logger.Debug(string.Format("Errore nel tentativo di contattare i servizi DOCUMENTUM: '{0}'", userName)); } /* * catch (Emc.Documentum.FS.Runtime.ServiceException exService) * { * //AuthenticationException - Exception in com.emc.documentum.fs.rt * //Exception which is raised when authentication errors occur * loginResult = DocsPaVO.utente.UserLogin.LoginResult.DTCM_SERVICE_NO_CONTACT; * retValue = false; * * logger.Debug(string.Format("Errore nel tentativo di contattare i servizi DTCM: '{0}'", userName)); * } */ catch (Exception ex) { //AuthenticationException - Exception in com.emc.documentum.fs.rt //Exception which is raised when authentication errors occur loginResult = DocsPaVO.utente.UserLogin.LoginResult.UNKNOWN_USER; retValue = false; logger.DebugFormat("Credenziali utente non DCTM valide: '{0}' msg {1} stk {2}", userName, ex.Message, ex.StackTrace); } return(retValue); }
/// <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> /// Reperimento istanza IObjectService /// </summary> /// <returns></returns> protected IObjectService GetObjectServiceInstance() { if (this._objectServiceInstance == null) { this._objectServiceInstance = DctmServiceFactory.GetServiceInstance <IObjectService>(this.InfoUtente.dst); } return(this._objectServiceInstance); }
/// <summary> /// /// </summary> /// <returns></returns> protected IQueryService GetQueryServiceInstance() { if (this._queryServiceInstance == null) { this._queryServiceInstance = DctmServiceFactory.GetServiceInstance <IQueryService>(UserManager.ImpersonateSuperUser()); } return(this._queryServiceInstance); }
/// <summary> /// /// </summary> /// <returns></returns> protected IQueryService GetQueryServiceInstance() { if (this._queryServiceInstance == null) { this._queryServiceInstance = DctmServiceFactory.GetServiceInstance <IQueryService>(this.InfoUtente.dst); } return(this._queryServiceInstance); }
/// <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> /// 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> /// Reperimento istanza servizio /// </summary> /// <typeparam name="T"></typeparam> /// <param name="asSuperUser"> /// Se true, si collega con le credenziali da superamministratore /// </param> /// <returns></returns> protected virtual T GetServiceInstance <T>(bool asSuperUser) { string dst = string.Empty; if (asSuperUser) { dst = UserManager.ImpersonateSuperUser(); } else { dst = this.InfoUtente.dst; } return(DctmServiceFactory.GetServiceInstance <T>(dst)); }
/// <summary> /// Verifica se un utente è contenuto in un gruppo DCTM /// </summary> /// <param name="groupName"></param> /// <param name="userId"></param> /// <returns></returns> public bool ContainsGroupUser(string groupName, string userId) { IQueryService queryServices = DctmServiceFactory.GetServiceInstance <IQueryService>(UserManager.ImpersonateSuperUser()); userId = DocsPaObjectTypes.TypeUtente.NormalizeUserName(userId); foreach (string user in Dfs4DocsPa.getUsersGroup(DocsPaObjectTypes.TypeGruppo.NormalizeGroupName(groupName), queryServices)) { if (user == userId) { return(true); } } return(false); }
/// <summary> /// Aggiornamento delle fascicolazioni /// </summary> /// <param name="idFolder"></param> public virtual bool UpdateFascicolazioni(string idFolder) { bool retValue = false; // Reperimento record di tipo "C" string idFolderC = DocsPaQueryHelper.getIdFolderCType(idFolder); try { IQueryService queryService = DctmServiceFactory.GetServiceInstance <IQueryService>(UserManager.ImpersonateSuperUser()); // 1. Reperimento di tutti i documenti contenuti in fascicolo in DCTM List <string> documentiInDctm = new List <string>(Dfs4DocsPa.getIdDocumentiInFascicolo(queryService, idFolder)); // 2. Reperimento di tutti i documenti contenuti in fascicolo in PITRE foreach (string idDocumento in DocsPaQueryHelper.getDocumentiInFolder(idFolderC)) { // 3. Per ogni documento contenuto nel fascicolo, verifica se esiste nel corrispondente fascicolo in DCTM if (!documentiInDctm.Contains(idDocumento)) { // 4. Verifica se il documento esiste in DCTM if (!Dfs4DocsPa.containsDocumento(idDocumento, queryService)) { throw new ApplicationException(string.Format("Documento con id '{0}' non esistente in Documentum", idDocumento)); } // 4. Inserimento del documento nel fascicolo in DCTM se non esiste if (!this.AddDocumentInFolder(idDocumento, idFolderC)) { throw new ApplicationException(string.Format("Errore in inserimento del documento con id '{0}' nel fascicolo con id '{1}'", idDocumento, idFolderC)); } } } retValue = true; } catch (Exception ex) { retValue = false; logger.Debug(string.Format("Errore in Documentum.UpdateFascicolazioni:\n{0}", ex.ToString())); } return(retValue); }
/// <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> /// Modifica password utente /// </summary> /// <param name="oldPassword"/></param> /// <param name="user"></param> ///// <returns></returns> public ValidationResultInfo ChangeUserPwd(DocsPaVO.utente.UserLogin user, string oldPassword) { ValidationResultInfo retValue = new ValidationResultInfo(); try { // La password deve essere modificata con le credenziali di superuser IObjectService objectService = DctmServiceFactory.GetServiceInstance <IObjectService>(UserManager.ImpersonateSuperUser()); ObjectIdentity identity = Dfs4DocsPa.getUserIdentityByName(TypeUtente.NormalizeUserName(user.UserName)); DataObject userDataObject = new DataObject(identity, ObjectTypes.UTENTE); userDataObject.Properties.Set <string>("user_password", user.Password); DataPackage dataPackage = new DataPackage(userDataObject); dataPackage = objectService.Update(dataPackage, null); retValue.Value = (dataPackage.DataObjects.Count > 0); if (!retValue.Value) { throw new ApplicationException("Password non aggiornata"); } else { RepositoryIdentity newIdentity = DctmRepositoryIdentityHelper.GetIdentity(DctmConfigurations.GetRepositoryName(), user.UserName, user.Password, string.Empty); user.DST = DctmRepositoryIdentityHelper.CreateAuthenticationToken(newIdentity); logger.Debug(string.Format("Documentum.ChangePassword: password modificata per l'utente {0}", user.UserName)); } } catch (Exception ex) { logger.Debug(string.Format("Errore in Documentum.ChangePassword:\n{0}", ex.ToString())); retValue.BrokenRules.Add(new BrokenRule("ChangePassword_ERROR", "Errore nella modifica della password per il documentale DOCUMENTUM", DocsPaVO.Validations.BrokenRule.BrokenRuleLevelEnum.Error)); } retValue.Value = (retValue.BrokenRules.Count == 0); return(retValue); }
/// <summary> /// Impostazione dell'ownership sul documento /// </summary> /// <param name="idProject"></param> /// <param name="ownerName"></param> /// <returns></returns> public virtual bool SetOwnershipFascicolo(string idFascicolo, string ownerName) { // Modifica del campo "owner_name" per il fascicolo e tutti gli eventuali sottofascicoli bool retValue = false; try { // Creazione queryservice con credenziali di superutente Dfs4DocsPa.setOwnershipFascicolo(idFascicolo, ownerName, DctmServiceFactory.GetServiceInstance <IQueryService>(UserManager.ImpersonateSuperUser())); retValue = true; } catch (Exception ex) { retValue = false; logger.Debug(string.Format("Errore in Documentum.SetOwnershipFascicolo:\n{0}", ex.ToString())); } return(retValue); }
/// <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> /// Rimozione di un fascicolo in un DCTM /// </summary> /// <param name="fascicolo"></param> /// <returns></returns> public bool DeleteProject(Fascicolo fascicolo) { bool retValue = false; try { // Rimozione oggetto fascicolo in DCTM DeleteProfile deleteProfile = new DeleteProfile(); deleteProfile.IsDeepDeleteFolders = true; deleteProfile.IsDeepDeleteChildrenInFolders = true; deleteProfile.IsDeepDeleteVdmInFolders = true; OperationOptions opts = new OperationOptions(); opts.DeleteProfile = deleteProfile; // Reperimento identity per il fascicolo ObjectIdentity identity = Dfs4DocsPa.getFascicoloProcedimentaleIdentityById(fascicolo.systemID); // Rimozione del fascicolo IObjectService objectService = DctmServiceFactory.GetServiceInstance <IObjectService>(UserManager.ImpersonateSuperUser()); objectService.Delete(new ObjectIdentitySet(identity), opts); // Rimozione dell'ACL associata al fascicolo this.DeleteAcl(Dfs4DocsPa.getAclDefinition(fascicolo.systemID, ObjectTypes.FASCICOLO, this.InfoUtente)); retValue = true; logger.Debug(string.Format("Documentum.DeleteFolder: rimosso fascicolo con id {0}", fascicolo.systemID)); } catch (Exception ex) { retValue = false; logger.Debug(string.Format("Errore in Documentum.DeleteProject:\n{0}", 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); }
/// <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> /// Verifica dell'esistenza di un titolario attivo in amministrazione /// </summary> /// <param name="codiceAmministrazione"></param> /// <returns></returns> public bool ContainsTitolarioAttivo(string codiceAmministrazione) { IQueryService queryService = DctmServiceFactory.GetServiceInstance <IQueryService>(UserManager.ImpersonateSuperUser()); return(Dfs4DocsPa.containsTitolarioAttivo(codiceAmministrazione, queryService)); }
/// <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> /////// 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> /// Ricerca fulltext nell'oggetto document /// /// nb: da fare anche ricerca allegati /// </summary> /// <param name="context"></param> /// <returns></returns> public ArrayList FullTextSearch(ref FullTextSearchContext context) { ArrayList result = new ArrayList(); try { List <string> fullTextResult = null; if (context.SearchResultList != null && context.SearchResultList.Length > 0) { // Ricerca già effettuata, reperimento dall'oggetto di contesto // dei risultati precedenti evitando così una dispendiosa // chiamata al sistema documentale fullTextResult = new List <string>(context.SearchResultList); } else { StructuredQuery strQuery = new StructuredQuery(); strQuery.AddRepository(DctmConfigurations.GetRepositoryName()); strQuery.ObjectType = ObjectTypes.DOCUMENTO; strQuery.IsDatabaseSearch = false; strQuery.IsIncludeAllVersions = false; strQuery.IsIncludeHidden = false; // Inserisce nella ricerca il solo cabinet dell'amministrazione RepositoryScope repositoryScope = new RepositoryScope(); repositoryScope.RepositoryName = DctmConfigurations.GetRepositoryName(); repositoryScope.LocationPath = DocsPaAdminCabinet.getRootAmministrazione(this.InfoUtente); repositoryScope.IsDescend = true; strQuery.Scopes.Add(repositoryScope); ExpressionSet set = new ExpressionSet(); set.AddExpression(new FullTextExpression(context.TextToSearch)); strQuery.RootExpressionSet = set; // Query execution int startIndex = (context.RequestedPageNumber * PAGE_SIZE) - PAGE_SIZE; int maxResults = this.GetMaxRowCount(); QueryExecution queryExec = new QueryExecution(startIndex, maxResults, maxResults); ISearchService searchService = DctmServiceFactory.GetServiceInstance <ISearchService>(this.InfoUtente.dst); QueryResult queryResult = searchService.Execute(strQuery, queryExec, null); QueryStatus queryStatus = queryResult.QueryStatus; RepositoryStatusInfo repStatusInfo = queryResult.QueryStatus.RepositoryStatusInfos[0]; if (repStatusInfo.Status == Status.FAILURE) { throw new ApplicationException("QueryResult: Status.FAILURE"); } fullTextResult = new List <string>(); foreach (DataObject dataObject in queryResult.DataObjects) { // Reperimento docnumber string docNumber = dataObject.Properties.Get(TypeDocumento.DOC_NUMBER).GetValueAsString(); if (!fullTextResult.Contains(docNumber)) // Eliminazione dei risultati duplicati { fullTextResult.Add(docNumber); } } context.SearchResultList = fullTextResult.ToArray(); context.TotalPageNumber = (fullTextResult.Count / PAGE_SIZE); context.TotalRecordCount = fullTextResult.Count; } // Paginazione dei risultati if (fullTextResult != null && fullTextResult.Count > 0) { int startIndex = (context.RequestedPageNumber * PAGE_SIZE) - PAGE_SIZE; int count = PAGE_SIZE; if (fullTextResult.Count < count) { count = fullTextResult.Count; } List <string> pageContent = fullTextResult.GetRange(startIndex, count); result = this.GetDocuments(pageContent.ToArray(), InfoUtente); } } catch (Exception ex) { result.Clear(); logger.Debug(string.Format("Errore in Documentum.FullTextSearch:\n{0}", ex.ToString())); } return(result); }
/// <summary> /// verifica che il server DCTM risponda correttamente, effettuando un controllo sulle credenziali dell'amministratore /// </summary> /// <returns></returns> public virtual bool Checkconnection() { bool retValue = false; string userAdm = DctmConfigurations.GetDocumentumSuperUser(); //loginResult = UserLogin.LoginResult.APPLICATION_ERROR; try { RepositoryIdentity identity = DctmServices.DctmRepositoryIdentityHelper.GetIdentity( DctmConfigurations.GetRepositoryName(), userAdm, DctmConfigurations.GetDocumentumSuperUserPwd(), ""); string token = DctmServices.DctmRepositoryIdentityHelper.CreateAuthenticationToken(identity); IObjectService objectService = DctmServiceFactory.GetServiceInstance <IObjectService>(token); Qualification qual = new Qualification("dm_docbaseid_map enable(RETURN_TOP 1)"); ObjectIdentity objectIdentity = new ObjectIdentity(qual, DctmConfigurations.GetRepositoryName()); objectIdentity.ValueType = ObjectIdentityType.QUALIFICATION; objectIdentity.valueTypeSpecified = true; DataPackage dataPackage = objectService.Get(new ObjectIdentitySet(objectIdentity), null); retValue = (dataPackage != null); } /* * catch (Emc.Documentum.FS.Runtime.AuthenticationException exAuth) * { * //AuthenticationException - Exception in com.emc.documentum.fs.rt * //Exception which is raised when authentication errors occur * // loginResult = DocsPaVO.utente.UserLogin.LoginResult.UNKNOWN_DTCM_USER; * retValue = false; * * logger.Error(string.Format("Credenziali utente DTCM non valide: '{0}'", userAdm + " " + exAuth.Message)); * } */ catch (Emc.Documentum.FS.Runtime.ServiceInvocationException exServiceInvocation) { //AuthenticationException - Exception in com.emc.documentum.fs.rt //Exception which is raised when authentication errors occur // loginResult = DocsPaVO.utente.UserLogin.LoginResult.DTCM_SERVICE_NO_CONTACT; retValue = false; logger.Error(string.Format("Errore nel tentativo di contattare i servizi DCTM: '{0}'", userAdm + " " + exServiceInvocation.Message)); } /* * catch (Emc.Documentum.FS.Runtime.ServiceException exService) * { * //AuthenticationException - Exception in com.emc.documentum.fs.rt * //Exception which is raised when authentication errors occur * // loginResult = DocsPaVO.utente.UserLogin.LoginResult.DTCM_SERVICE_NO_CONTACT; * retValue = false; * * logger.Error(string.Format("Errore nel tentativo di contattare i servizi DTCM: '{0}'", userAdm + " " + exService.Message)); * } */ catch (Exception ex) { //AuthenticationException - Exception in com.emc.documentum.fs.rt //Exception which is raised when authentication errors occur // loginResult = DocsPaVO.utente.UserLogin.LoginResult.UNKNOWN_USER; retValue = false; logger.Error(string.Format("Error durante il controllo checkpage utente : '{0}'", userAdm + " errore: " + ex.Message)); } return(retValue); }
/// <summary> /// Verifica dell'esistenza in dctm di un nodo di titolario /// </summary> /// <param name="idNodoTitolario"></param> /// <returns></returns> public bool ContainsNodoTitolario(string idNodoTitolario) { IQueryService queryService = DctmServiceFactory.GetServiceInstance <IQueryService>(UserManager.ImpersonateSuperUser()); return(Dfs4DocsPa.containsNodoTitolario(idNodoTitolario, queryService)); }