/// <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> /// 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); }
private void inserisciUtenteInAmministrazione(OrgUtente utente, DataObject userDataObject) { string codiceAmm = DocsPaQueryHelper.getCodiceAmministrazione(utente.IDAmministrazione); string gruppoAmm = TypeGruppo.GetGroupNameForAmministrazione(codiceAmm); try { //inserimento del nuovo utente nel gruppo associato alla amministrazione IQueryService qrySrvc = this.GetQueryServiceInstance(); DfsHelper.insertUserInGroup(TypeUtente.getUserName(utente), gruppoAmm, qrySrvc); // eventuale inserimento nel gruppo dei syadmin if (utente.Amministratore != null && utente.Amministratore != "0") { gruppoAmm = TypeGruppo.GetGroupNameForSysAdminAmministrazione(codiceAmm); DfsHelper.insertUserInGroup(TypeUtente.getUserName(utente), gruppoAmm, qrySrvc); } } catch (Exception e) { string msg = string.Format( DEBUG_HEADER + ": errore in inserimento utente {0} nel gruppo {1}: {2}", TypeUtente.getUserName(utente), gruppoAmm, e.ToString()); logger.Debug(msg); undoCreateUser(utente); throw new ApplicationException(msg, e); } }
/// <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> /// Aggiornamento delle proprietà dell'oggetto "p3_document" /// </summary> /// <param name="idCheckOut"></param> /// <param name="documentNumber"></param> /// <param name="machineName"></param> /// <param name="documentLocation"></param> /// <returns></returns> private bool SaveCheckOutDocumentProperties(string idCheckOut, string documentNumber, string documentLocation, string machineName) { bool retValue = false; try { // Determina se il documento da bloccare è di tipo stampa registro bool isStampaRegistro = (DocsPaQueryHelper.isStampaRegistro(documentNumber)); ObjectIdentity identity = null; if (!string.IsNullOrEmpty(idCheckOut)) { identity = DfsHelper.createObjectIdentityObjId(idCheckOut); } else { if (DocsPaQueryHelper.isStampaRegistro(documentNumber)) { identity = Dfs4DocsPa.getDocumentoStampaRegistroIdentityByDocNumber(documentNumber); } else { identity = Dfs4DocsPa.getDocumentoIdentityByDocNumber(documentNumber); } } DataObject dataObject = new DataObject(identity); dataObject.Properties = new PropertySet(); List <Property> propertyList = new List <Property>(); propertyList.Add(new StringProperty(TypeDocumento.CHECKOUT_LOCAL_FILE_PATH, documentLocation)); propertyList.Add(new StringProperty(TypeDocumento.CHECKOUT_MACHINE_NAME, machineName)); dataObject.Properties.Properties.AddRange(propertyList); DataPackage dataPackage = new DataPackage(dataObject); dataPackage.RepositoryName = dataObject.Identity.RepositoryName; IObjectService service = this.GetServiceInstance <IObjectService>(false); dataPackage = service.Update(dataPackage, null); retValue = (dataPackage.DataObjects.Count > 0); } catch (Exception ex) { retValue = false; logger.Debug("Errore in Documentum. SaveCheckOutDocumentProperties: " + ex.ToString()); } return(retValue); }
/// <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> /// UndoCheckout di un documento in stato checkout /// </summary> /// <param name="checkOutStatus"></param> /// <param name="library"></param> /// <returns></returns> public bool UndoCheckOut(DocsPaVO.CheckInOut.CheckOutStatus checkOutStatus) { bool retValue = false; try { ObjectIdentity identity = null; // Reperimento identity del documento da sbloccare if (DocsPaQueryHelper.isStampaRegistro(checkOutStatus.DocumentNumber)) { identity = Dfs4DocsPa.getDocumentoStampaRegistroIdentityByDocNumber(checkOutStatus.DocumentNumber); } else { identity = Dfs4DocsPa.getDocumentoIdentityByDocNumber(checkOutStatus.DocumentNumber); } ObjectIdentitySet identitySet = new ObjectIdentitySet(); identitySet.Identities.Add(identity); // Reperimento degli ObjectIdentity per ciascun allegato del documento identitySet.Identities.AddRange(Dfs4DocsPa.getAllegatiDocumentoIdentities(this.GetServiceInstance <IQueryService>(false), checkOutStatus.DocumentNumber)); IVersionControlService service = this.GetServiceInstance <IVersionControlService>(false); service.CancelCheckout(identitySet); retValue = true; if (retValue) { this.ClearCheckOutStatusObject(checkOutStatus); retValue = this.SaveCheckOutDocumentProperties(checkOutStatus); if (retValue) { logger.Debug(string.Format("Documentum.UndoCheckOut: effettuato l'undocheckout del documento con id {0} e docnumber {1}", checkOutStatus.IDDocument, checkOutStatus.DocumentNumber)); } } } catch (Exception ex) { retValue = false; logger.Debug("Errore in Documentum.UndoCheckOut: " + ex.ToString()); } return(retValue); }
/// <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); }
public void InserisciUtenteInAmm(OrgUtente utente) { string codiceAmm = DocsPaQueryHelper.getCodiceAmministrazione(utente.IDAmministrazione); string gruppoAmm = TypeGruppo.GetGroupNameForAmministrazione(codiceAmm); try { //inserimento del nuovo utente nel gruppo associato alla amministrazione IQueryService qrySrvc = this.GetQueryServiceInstance(); DfsHelper.insertUserInGroup(TypeUtente.getUserName(utente), gruppoAmm, qrySrvc); } catch (Exception e) { string msg = string.Format( DEBUG_HEADER + ": errore in inserimento utente {0} nel gruppo {1}: {2}", TypeUtente.getUserName(utente), gruppoAmm, e.ToString()); logger.Debug(msg); throw new ApplicationException(msg, e); } }
/// <summary> /// /// </summary> /// <param name="thing"></param> /// <returns></returns> public static CorteContentServices.GrantsType getAclSecurity(string thing) { // Reperimento metadati in tabella Security di DocsPa List <UserGrantType> userGrantList = new List <UserGrantType>(); List <GroupGrantType> groupGrantList = new List <GroupGrantType>(); CorteContentServices.UserGrantType userGrant; CorteContentServices.GroupGrantType groupGrant; CorteContentServices.GrantsType grants = new CorteContentServices.GrantsType(); foreach (DocsPaQueryHelper.DocsPaSecurityItem securityItem in DocsPaQueryHelper.getSecurityItems(thing)) { if (securityItem.IsPeople) { userGrant = new CorteContentServices.UserGrantType(); userGrant.userId = securityItem.CodiceRubrica; userGrant.accessType = DocsPaObjectType.ObjectTypes.ROLE_READER; userGrantList.Add(userGrant); } else { groupGrant = new CorteContentServices.GroupGrantType(); groupGrant.name = securityItem.CodiceRubrica; groupGrant.accessType = DocsPaObjectType.ObjectTypes.ROLE_READER; groupGrantList.Add(groupGrant); } } if (userGrantList.Count > 0) { grants.usersGrant = userGrantList.ToArray(); } if (groupGrantList.Count > 0) { grants.groupsGrant = groupGrantList.ToArray(); } return(grants); }
/// <summary> /// Reperimento dei metadati sullo stato del checkout del documento /// </summary> /// <param name="idDocument"></param> /// <param name="documentNumber"></param> /// <returns></returns> protected virtual CheckOutStatus GetCheckOutStatus(string dctmId, string idDocument, string documentNumber) { CheckOutStatus retValue = null; bool isStampaRegistro = (DocsPaQueryHelper.isStampaRegistro(documentNumber)); PropertySet propertySet = this.LoadCheckOutProperties(documentNumber, isStampaRegistro); // Reperimento nome dell'utente che ha bloccato il documento string lockOwner = propertySet.Get("r_lock_owner").GetValueAsString(); if (!string.IsNullOrEmpty(lockOwner)) { // Se il documento è in stato checkout, creazione dell'oggetto "CheckOutStatus" retValue = new CheckOutStatus(); retValue.ID = dctmId; retValue.UserName = lockOwner; retValue.IDDocument = idDocument; retValue.DocumentNumber = documentNumber; DateProperty checkOutDate = (DateProperty)propertySet.Get("r_lock_date"); retValue.CheckOutDate = checkOutDate.Value.Value; // Attributi custom che è stato necessario aggiungere in documentum retValue.DocumentLocation = propertySet.Get(TypeDocumento.CHECKOUT_LOCAL_FILE_PATH).GetValueAsString(); retValue.MachineName = propertySet.Get(TypeDocumento.CHECKOUT_MACHINE_NAME).GetValueAsString(); if (!isStampaRegistro) { // Reperimento segnatura, solo se il documento è un protocollo string tipoProto = propertySet.Get(TypeDocumento.TIPO_PROTOCOLLO).GetValueAsString(); if (tipoProto.ToUpper() != "G") { retValue.Segnature = propertySet.Get("object_name").GetValueAsString(); } } } return(retValue); }
/// <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> /// 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> /// Reperimento dei metadati da documentum relativamente allo stato checkedout del documento /// </summary> /// <param name="documentNumber"></param> /// <returns></returns> protected virtual CheckoutInfo GetDctmCheckOutInfo(string documentNumber) { ObjectIdentity identity = null; // Reperimento identity del documento da bloccare if (DocsPaQueryHelper.isStampaRegistro(documentNumber)) { identity = Dfs4DocsPa.getDocumentoStampaRegistroIdentityByDocNumber(documentNumber); } else { identity = Dfs4DocsPa.getDocumentoIdentityByDocNumber(documentNumber); } if (identity.ValueType == ObjectIdentityType.QUALIFICATION) { logger.Debug(((Qualification)identity.Value).GetValueAsString()); } ObjectIdentitySet identitySet = new ObjectIdentitySet(); identitySet.Identities.Add(identity); //IVersionControlService service = this.GetVersionServiceInstance(); IVersionControlService service = this.GetServiceInstance <IVersionControlService>(true); List <CheckoutInfo> checkOutInfoList = service.GetCheckoutInfo(identitySet); if (checkOutInfoList != null && checkOutInfoList.Count > 0) { return(checkOutInfoList[0]); } else { return(null); } }
/// <summary> /// /// </summary> /// <param name="ruolo"></param> /// <returns></returns> public static string GetGroupName(DocsPaVO.amministrazione.OrgRuolo ruolo) { return(NormalizeGroupName(DocsPaQueryHelper.getCodiceRuoloFromIdGroups(ruolo.IDGruppo))); }
/// <summary> /// /// </summary> /// <param name="ruolo"></param> /// <returns></returns> public static string GetGroupNameByidCorr(string idCorr) { return(NormalizeGroupName(DocsPaQueryHelper.getCodiceRuoloFromIdCorr(idCorr))); }
/// <summary> /// /// </summary> /// <param name="ruolo"></param> /// <returns></returns> public static string GetGroupName(DocsPaVO.utente.Ruolo ruolo) { return(NormalizeGroupName(DocsPaQueryHelper.getCodiceRuoloFromIdGroups(ruolo.idGruppo))); }
/// <summary> /// Modifica dei dati di un utente in amministrazione /// </summary> /// <param name="utente"></param> /// <returns></returns> public EsitoOperazione ModificaUtente(OrgUtente utente) { EsitoOperazione ret = new EsitoOperazione(); string logMsg = string.Empty; IObjectService objSrvc = null; IQueryService qrySvc = null; string repositoryName = DctmConfigurations.GetRepositoryName(); bool wasSysAdmin = false; bool isSysAdmin = false; string gruppoSysAdm; string codiceAmm; // test sui campi obbligatori if (string.IsNullOrEmpty(utente.Codice) || string.IsNullOrEmpty(utente.Email) || string.IsNullOrEmpty(utente.IDPeople) || string.IsNullOrEmpty(utente.UserId)) { logMsg = ERR_HEADER + "ModificaUtente: dati insufficienti"; ret.Codice = -1; ret.Descrizione = logMsg; logger.Debug(logMsg); return(ret); } try { objSrvc = this.GetObjectServiceInstance(); qrySvc = this.GetQueryServiceInstance(); ObjectIdentity userIdentity = Dfs4DocsPa.getUserIdentityByName(TypeUtente.getUserName(utente)); // non è possibile cambiare il nome di un utente List <string> filters = new List <string>(); filters.Add("user_name"); DataObject oldData = DfsHelper.getAllPropsAndFolders(objSrvc, userIdentity, filters, false); Property oldName = oldData.Properties.Get("user_name"); if (oldName == null) { ret.Codice = -1; logMsg = ERR_HEADER + "ModificaUtente: impossibile leggere il vecchio nome dell'utente"; ret.Descrizione = logMsg; logger.Debug(logMsg); return(ret); } if (!oldName.GetValueAsString().Equals(utente.UserId, StringComparison.OrdinalIgnoreCase)) { ret.Codice = -1; logMsg = ERR_HEADER + "ModificaUtente: non è possibile modificare il nome dell'utente"; ret.Descrizione = logMsg; logger.Debug(logMsg); return(ret); } // dobbiamo capire se prima dell'update era sysAdmin oppure no codiceAmm = DocsPaQueryHelper.getCodiceAmministrazione(utente.IDAmministrazione); gruppoSysAdm = TypeGruppo.GetGroupNameForSysAdminAmministrazione(codiceAmm); wasSysAdmin = DfsHelper.isUserMemberOf(TypeUtente.getUserName(utente), gruppoSysAdm, qrySvc); isSysAdmin = (utente.Amministratore != null && utente.Amministratore != "0"); // verifico se sia stata modificata la password o meno // if (!string.IsNullOrEmpty(utente.Password)) // { // eliminato controllo su presenza password, gli altri dati dell'utente devono essere modificati // anche senza un cambio password (speriamo almeno..) Necessario per replicare stato attivazione rispetto a docspa. // il campo password non viene passato se non è valorizzato DataObject userData = new DataObject(userIdentity, ObjectTypes.UTENTE); // Reperimento properties utente userData.Properties.Properties.AddRange(Dfs4DocsPa.getUserProperties(utente)); DataPackage pkg = new DataPackage(userData); pkg = objSrvc.Update(pkg, null); if (pkg.DataObjects.Count > 0) { // eventuale inserimento nel gruppo dei syadmin if (isSysAdmin && !wasSysAdmin) { DfsHelper.insertUserInGroup(TypeUtente.getUserName(utente), gruppoSysAdm, qrySvc); } else if (wasSysAdmin && !isSysAdmin) { DfsHelper.removeUserFromGroup(TypeUtente.getUserName(utente), gruppoSysAdm, qrySvc); } ret.Codice = 0; ret.Descrizione = string.Empty; logger.Debug(DEBUG_HEADER + "ModificaUtente completata con SUCCESSO"); } else { throw new ApplicationException(); } /** } * else * { * ret.Codice = 0; * ret.Descrizione = string.Empty; * * logger.Debug(DEBUG_HEADER + "ModificaUtente completata con SUCCESSO"); * } */ return(ret); } catch (Exception ex) { String st = ex.ToString(); logger.Error(DEBUG_HEADER + "ModificaUtente FALLITA, Exception=" + st); ret.Codice = -1; ret.Descrizione = ERR_HEADER + "ModificaUtente"; return(ret); } }
/// <summary> /// Attivazione di un titolario /// </summary> /// <param name="titolario"></param> /// <returns></returns> public bool AttivaTitolario(OrgTitolario titolario) { bool retValue = true; try { // Verifica della presenza di un titolario attivo string repositoryName = DctmConfigurations.GetRepositoryName(); IObjectService objSrvc = this.GetObjectServiceInstance(); // Verifica se in documentum è presente un titolario attivo bool existTitolarioAttivo = (Dfs4DocsPa.containsTitolarioAttivo(titolario.CodiceAmministrazione, this.GetQueryServiceInstance())); DataObject dataObjectTitolarioAttivo = null; if (existTitolarioAttivo) { // Reperimento oggetto identity per il titolario attivo ObjectIdentity identity = Dfs4DocsPa.getTitolarioAttivoIdentity(titolario.CodiceAmministrazione); // Reperimento oggetto DataObject relativo al titolario attivo (se presente) List <string> filters = new List <string>(); filters.Add(TypeTitolario.ID_DOCSPA); dataObjectTitolarioAttivo = DfsHelper.getAllPropsAndFolders(objSrvc, identity, filters, false); string idDocsPa = dataObjectTitolarioAttivo.Properties.Get(TypeTitolario.ID_DOCSPA).GetValueAsString(); // Reperimento del titolario appena chiuso in docspa, cui corrisponde il titolario da chiudere in documentum OrgTitolario titolarioChiuso = DocsPaQueryHelper.getTitolario(idDocsPa); dataObjectTitolarioAttivo = new DataObject(); dataObjectTitolarioAttivo.Identity = Dfs4DocsPa.getTitolarioIdentity(titolarioChiuso.ID); dataObjectTitolarioAttivo.Type = ObjectTypes.TITOLARIO; dataObjectTitolarioAttivo.Properties = new PropertySet(); dataObjectTitolarioAttivo.Properties.Properties.AddRange(Dfs4DocsPa.getTitolarioProperties(titolarioChiuso)); } // Reperimento identity titolario in definizione ObjectIdentity identityTitolarioInDef = Dfs4DocsPa.getTitolarioIdentity(titolario.ID); DataObject dataObjectTitolarioInDef = new DataObject(); dataObjectTitolarioInDef.Identity = identityTitolarioInDef; dataObjectTitolarioInDef.Type = ObjectTypes.TITOLARIO; dataObjectTitolarioInDef.Properties = new PropertySet(); dataObjectTitolarioInDef.Properties.Properties.AddRange(Dfs4DocsPa.getTitolarioProperties(titolario)); List <DataObject> dataObjectList = new List <DataObject>(); if (existTitolarioAttivo) { dataObjectList.Add(dataObjectTitolarioAttivo); } dataObjectList.Add(dataObjectTitolarioInDef); // Creazione oggetto DataPackage DataPackage dataPackage = new DataPackage(); dataPackage.DataObjects.AddRange(dataObjectList); dataPackage = objSrvc.Update(dataPackage, null); string objectId = ((ObjectId)dataPackage.DataObjects[0].Identity.Value).Id.ToString(); retValue = (!string.IsNullOrEmpty(objectId)); if (retValue) { logger.Debug(string.Format("Documentum.AttivaTitolario: attivato titolario con id {0}", titolario.ID)); } } catch (Exception ex) { retValue = false; logger.Debug("Errore in Documentum.AttivaTitolario: " + ex.ToString()); } return(retValue); }
/// <summary> /// Checkin di un documento in stato checkout /// </summary> /// <param name="checkOutStatus"></param> /// <param name="library"></param> /// <returns></returns> public bool CheckIn(DocsPaVO.CheckInOut.CheckOutStatus checkOutStatus, byte[] content, string checkInComments) { bool retValue = false; try { // Creazione di un nuovo DataObject che rappresenta il documento da sbloccare DataObject dataObject = new DataObject(); dataObject.Type = ObjectTypes.DOCUMENTO; // Reperimento identity del documento da sbloccare if (DocsPaQueryHelper.isStampaRegistro(checkOutStatus.DocumentNumber)) { dataObject.Identity = Dfs4DocsPa.getDocumentoStampaRegistroIdentityByDocNumber(checkOutStatus.DocumentNumber); } else { dataObject.Identity = Dfs4DocsPa.getDocumentoIdentityByDocNumber(checkOutStatus.DocumentNumber); } List <Property> propertyList = new List <Property>(); // Impostazione numero versione propertyList.Add(new NumberProperty(TypeDocumento.NUMERO_VERSIONE, DocsPaQueryHelper.getDocumentNextVersionId(checkOutStatus.IDDocument))); // Rimozione valore proprietà p3_locked_filepath propertyList.Add(new StringProperty(TypeDocumento.CHECKOUT_LOCAL_FILE_PATH, string.Empty)); // Rimozione valore proprietà p3_locked_file_machinename propertyList.Add(new StringProperty(TypeDocumento.CHECKOUT_MACHINE_NAME, string.Empty)); dataObject.Properties = new PropertySet(); dataObject.Properties.Properties.AddRange(propertyList); // Temporaneo, inserimento contentuto file OperationOptions opts = new OperationOptions(); CheckinProfile checkInProfile = new CheckinProfile(); checkInProfile.MakeCurrent = true; checkInProfile.DeleteLocalFileHint = true; opts.Profiles.Add(checkInProfile); // Creazione di un nuovo oggetto BinaryContent BinaryContent binaryContent = new BinaryContent(); binaryContent.Value = content; string ext = System.IO.Path.GetExtension(checkOutStatus.DocumentLocation); if (ext.StartsWith(".")) { ext = ext.Substring(1); } string fileFormat = DfsHelper.getDctmFileFormat(this.GetServiceInstance <IQueryService>(false), ext); binaryContent.Format = fileFormat; dataObject.Contents.Add(binaryContent); DataPackage dataPackage = new DataPackage(dataObject); dataPackage.RepositoryName = DctmConfigurations.GetRepositoryName(); IVersionControlService service = this.GetServiceInstance <IVersionControlService>(false); VersionStrategy strategy = VersionStrategy.IMPLIED; if (!DocsPaQueryHelper.isDocumentAcquisito(checkOutStatus.IDDocument)) { strategy = VersionStrategy.SAME_VERSION; } dataPackage = service.Checkin(dataPackage, strategy, false, null, opts); retValue = (dataPackage.DataObjects.Count > 0); if (retValue) { logger.Debug(string.Format("Documentum.CheckIn: effettuato il checkin del documento con id {0} e docnumber {1}", checkOutStatus.IDDocument, checkOutStatus.DocumentNumber)); } } catch (Exception ex) { retValue = false; logger.Debug("Errore in Documentum.CheckIn: " + ex.ToString()); } return(retValue); }
/// <summary> /// Rimozione di un documento da un folder /// </summary> /// <param name="idProfile"></param> /// <param name="folder"></param> /// <returns></returns> public bool RemoveDocumentFromFolder(string idProfile, DocsPaVO.fascicolazione.Folder folder) { bool retValue = false; // Reperimento docNumber da idProfile logger.Debug("Reperimento docNumber da idProfile"); string docNumber = DocsPaQueryHelper.getDocNumber(idProfile); bool isStampaRegistro = DocsPaQueryHelper.isStampaRegistroRepertorio(docNumber); try { logger.Debug("getDocumentoIdentityByDocNumber"); ObjectIdentity documentIdentity = Dfs4DocsPa.getDocumentoIdentityByDocNumber(docNumber); if (isStampaRegistro) { documentIdentity = Dfs4DocsPa.getDocumentoStampaRegistroIdentityByDocNumber(docNumber); } ObjectIdentity folderIdentity = null; // Verifica se l'id è relativo ad un fascicolo o a un sottofascicolo logger.Debug("Verifica se l'id è relativo ad un fascicolo o a un sottofascicolo"); if (!DocsPaQueryHelper.isSottofascicolo(folder.systemID)) { folderIdentity = Dfs4DocsPa.getFascicoloIdentityBySystemId(folder.idFascicolo); } else { folderIdentity = DctmServices.Dfs4DocsPa.getSottofascicoloIdentityById(folder.systemID); } logger.Debug("createRemoveParentFolder"); ReferenceRelationship removeRelationship = DctmServices.DfsHelper.createRemoveParentFolder(folderIdentity); logger.Debug("updatedDoc.Relationships"); DataObject updatedDoc = new DataObject(documentIdentity); updatedDoc.Relationships.Add(removeRelationship); DataPackage dp = new DataPackage(updatedDoc); logger.Debug("update"); IObjectService objSrvc = DctmServiceFactory.GetServiceInstance <IObjectService>(UserManager.ImpersonateSuperUser()); DataPackage retDp = objSrvc.Update(dp, null); retValue = (retDp.DataObjects.Count > 0); if (retValue) { logger.Debug(string.Format("Documentum.RemoveDocumentFromFolder: rimosso documento con docnumber {0} dal sottofascicolo con id {0}", idProfile, folder.systemID)); } } catch (Exception ex) { retValue = false; logger.Debug(string.Format("Errore in Documentum.RemoveDocumentFromFolder:\n{0}", ex.ToString())); } return(retValue); }
/// <summary> /// Rimozione di un documento dal fascicolo (in generale, da tutti i folder presenti nel fascicolo) /// </summary> /// <param name="idProfile"></param> /// <param name="folder"></param> /// <returns></returns> public bool RemoveDocumentFromProject(string idProfile, DocsPaVO.fascicolazione.Folder folder) { logger.Debug(string.Format("RemoveDocumentFromProject - IdProfile: {0} - IdFolder: {1} - IdFascicolo: {2}", idProfile, folder.systemID, folder.idFascicolo)); // 1. recuperare tutti link del documento // 2. identificare quelli da rimuovere (tutti quelli sotto il folder in input) // 3. aggiungere eventualmente il link a documenti non classificati // (se non c'è neanche più un link residuo) bool retValue = false; IObjectService objSrvc = null; // Reperimento docNumber da idProfile string docNumber = DocsPaQueryHelper.getDocNumber(idProfile); bool isStampaRegistro = DocsPaQueryHelper.isStampaRegistroRepertorio(docNumber); try { string repositoryName = DctmConfigurations.GetRepositoryName(); //objSrvc = this.GetObjectServiceInstance(); objSrvc = DctmServiceFactory.GetServiceInstance <IObjectService>(UserManager.ImpersonateSuperUser()); List <Relationship> removeRelationships = new List <Relationship>(); // 1. recuperare tutti link del documento: ObjectIdentity documentIdentity = Dfs4DocsPa.getDocumentoIdentityByDocNumber(docNumber); if (isStampaRegistro) { documentIdentity = Dfs4DocsPa.getDocumentoStampaRegistroIdentityByDocNumber(docNumber); } logger.Debug("RemoveDocumentFromProject: 1.recuperare tutti link del documento"); List <string> filters = new List <string>(); filters.Add("r_object_id"); DataObject documentData = DfsHelper.getAllPropsAndFolders(objSrvc, documentIdentity, filters, true); // 2. identificare quelli da rimuovere (tutti quelli sotto il folder in input): if (documentData.Relationships != null && documentData.Relationships.Count > 0) { logger.Debug("RemoveDocumentFromProject: 2. identificare quelli da rimuovere (tutti quelli sotto il folder in input)"); // 2a. recuperiamo la root del nodo associato a Folder: ObjectIdentity folderIdentity = Dfs4DocsPa.getFascicoloIdentityBySystemId(folder.idFascicolo); if (folderIdentity.ValueType == ObjectIdentityType.QUALIFICATION) { logger.Debug(((Qualification)folderIdentity.Value).GetValueAsString()); } filters = new List <string>(); filters.Add("r_folder_path"); DataObject folderData = DfsHelper.getAllPropsAndFolders(objSrvc, folderIdentity, filters, false); Property p = folderData.Properties.Get("r_folder_path"); if (p == null) { throw new Exception("Impossibile leggere r_folder_path"); } string rootPath = p.GetValueAsString(); logger.Debug(string.Format("RemoveDocumentFromProject: RootPath: {0}", rootPath)); foreach (ReferenceRelationship r in documentData.Relationships) { // 2b. recuperiamo il path del folder in esame // qui contiamo sul fatto che gli objectIdentity dei folder a cui è linkato vengano istanziati // come OBJECT_ID string targetDctmId = ((ObjectId)r.Target.Value).Id; logger.Error(string.Format("LOG-DEBUG: RemoveDocumentFromProject: targetDctmId: {0}", targetDctmId)); ObjectIdentity targetIdentity = new ObjectIdentity(new ObjectId(targetDctmId), repositoryName); DataObject targetData = DfsHelper.getAllPropsAndFolders(objSrvc, targetIdentity, filters, false); Property prop = targetData.Properties.Properties.Find(e => e.Name == "r_folder_path"); if (prop != null) { string targetPath = targetData.Properties.Get("r_folder_path").GetValueAsString(); logger.Debug(string.Format("RemoveDocumentFromProject: targetPath: {0}", targetPath)); //se il target è sotto la root allora è da rimuovere if (targetPath.StartsWith(rootPath)) { removeRelationships.Add(DfsHelper.createRemoveParentFolder(targetIdentity)); } } } } // 3. committare il tutto DataObject updatedDoc = new DataObject(documentIdentity); updatedDoc.Relationships = removeRelationships; DataPackage dp = new DataPackage(updatedDoc); DataPackage retDp = objSrvc.Update(dp, null); logger.Debug("RemoveDocumentFromProject: 3. committare il tutto"); if (retDp.DataObjects.Count > 0) { retValue = true; logger.Debug(string.Format("Documentum.RemoveDocumentFromProject: rimosso documento con docnumber {0} dal fascicolo con id {0}", idProfile, folder.systemID)); } } catch (Exception e) { retValue = false; logger.Debug(string.Format("Errore in Documentum.RemoveDocumentFromProject:\n{0}", e.ToString())); } return(retValue); }
/// <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> /// Cancellazione di un'amministrazione nel documentale /// </summary> /// <param name="info"></param> /// <returns></returns> public EsitoOperazione Delete(InfoAmministrazione info) { return(this.Delete(info, DocsPaQueryHelper.getGroupNames(info.IDAmm))); }
/// <summary> /// Verifica se un utente è contenuto in un gruppo DCTM /// </summary> /// <param name="idGroup"></param> /// <param name="idPeople"></param> /// <returns></returns> public bool ContainsGroupUserById(string idGroup, string idPeople) { return(this.ContainsGroupUser(DocsPaQueryHelper.getCodiceRuoloFromIdGroups(idGroup), DocsPaQueryHelper.getCodiceUtente(idPeople))); }
/// <summary> /// Checkout di un documento /// </summary> /// <param name="checkOutStatus">Metadati relativi allo stato del documento in checkout</param> /// <param name="user"></param> /// <param name="library"></param> /// <returns></returns> public bool CheckOut(string idDocument, string documentNumber, string documentLocation, string machineName, out CheckOutStatus checkOutStatus) { checkOutStatus = null; // Determina se il documento da bloccare è di tipo stampa registro bool isStampaRegistro = (DocsPaQueryHelper.isStampaRegistro(documentNumber)); bool retValue = this.SaveCheckOutDocumentProperties(string.Empty, documentNumber, documentLocation, machineName); try { if (retValue) { ObjectIdentity identity = null; // Reperimento identity del documento da bloccare if (isStampaRegistro) { identity = Dfs4DocsPa.getDocumentoStampaRegistroIdentityByDocNumber(documentNumber); } else { identity = Dfs4DocsPa.getDocumentoIdentityByDocNumber(documentNumber); } ObjectIdentitySet identitySet = new ObjectIdentitySet(); identitySet.Identities.Add(identity); OperationOptions opts = null; if (DocsPaQueryHelper.getCountAllegati(idDocument) > 0) { // Se il documento contiene allegati, è sicuramente un virtual document CheckoutProfile checkOutProfile = new CheckoutProfile(); // Ulteriore verifica se il documento è un allegato o un documento principale checkOutProfile.CheckoutOnlyVDMRoot = !DocsPaQueryHelper.isAllegatoProfilato(documentNumber); opts = new OperationOptions(); opts.CheckoutProfile = checkOutProfile; } IVersionControlService service = this.GetServiceInstance <IVersionControlService>(false); DataPackage dataPackage = service.Checkout(identitySet, opts); // Reperimento ObjectId della versione in checkout ObjectId objectId = (ObjectId)dataPackage.DataObjects[0].Identity.Value; checkOutStatus = this.GetCheckOutStatus(objectId.Id, idDocument, documentNumber); //if (DocsPaQueryHelper.getCountAllegati(idDocument) > 0) //{ // // Workaround per gli allegati // this.UndoCheckOutAllegati(documentNumber); //} retValue = true; logger.Debug(string.Format("Documentum.CheckOut: effettuato il checkout del documento con id {0} e docnumber {1}", idDocument, documentNumber)); } } catch (Exception ex) { retValue = false; logger.Debug("Errore in Documentum.CheckOut: " + ex.ToString()); } return(retValue); }
/// <summary> /// Inserimento di un documento in un folder /// </summary> /// <param name="idProfile"></param> /// <param name="idFolder"></param> /// <returns></returns> public bool AddDocumentInFolder(string idProfile, string idFolder) { logger.Info("BEGIN"); bool retValue = false; // Reperimento idfolder per il record di tipo "C" in docspa (root folder) idFolder = DocsPaQueryHelper.getIdFolderCType(idFolder); // Reperimento docNumber da idProfile string docNumber = DocsPaQueryHelper.getDocNumber(idProfile); //bool stampaRegistro = DocsPaQueryHelper.isStampaRegistro(docNumber); bool stampaRegistro = DocsPaQueryHelper.isStampaRegistroRepertorio(docNumber); try { IObjectService objectService = DctmServiceFactory.GetServiceInstance <IObjectService>(UserManager.ImpersonateSuperUser()); // 1. recuperare il documento con tutti i link a folder attuali ObjectIdentity documentIdentity = Dfs4DocsPa.getDocumentoIdentityByDocNumber(docNumber); if (stampaRegistro) { documentIdentity = Dfs4DocsPa.getDocumentoStampaRegistroIdentityByDocNumber(docNumber); } // 2. Creare il nuovo link al folder di classificazione ObjectIdentity folderIdentity = null; // Verifica se l'idFolder si riferisce ad un fascicolo o a un sottofascicolo if (!DocsPaQueryHelper.isSottofascicolo(idFolder)) { // Reperimento id del fascicolo dal folder (record tipo "C") string tipoFascicolo; string idFascicolo = DocsPaQueryHelper.getIdFascicoloFromFolder(idFolder, out tipoFascicolo); folderIdentity = Dfs4DocsPa.getFascicoloIdentityBySystemId(idFascicolo); //Effettuo un refresh dei permessi sul fascicolo per allineare le ACL con DOCUMENTUM //Fascicolo fascicolo = DocsPaQueryHelper.getFascicolo(idFascicolo, this.InfoUtente); //if (fascicolo != null) // RefreshAclFascicolo(fascicolo); } else { folderIdentity = Dfs4DocsPa.getSottofascicoloIdentityById(idFolder); } ReferenceRelationship addRelationship = DfsHelper.createParentFolderRelationship(folderIdentity); //la aggiungeremo alla lista degli update nell'ultimo passo // 3. salvare DataObject updatedDoc = new DataObject(documentIdentity); updatedDoc.Relationships.Add(addRelationship); // 4. Allineamento ACL documento: // per coerenza è necessario che, una volta che il documento // viene inserito in un fascicolo, questo diventi visibile anche // a tutti gli utenti che hanno la visibilità solo sul fascicolo e // non sul documento this.UpdateAclDocumento(idProfile, docNumber); DataPackage dataPackage = new DataPackage(updatedDoc); dataPackage = objectService.Update(dataPackage, null); retValue = (dataPackage.DataObjects.Count > 0); if (retValue) { logger.Debug(string.Format("Documentum.AddDocumentInFolder: inserito il documento con docnumber {0} nel folder con id {1}", idProfile, idFolder)); } } catch (Exception ex) { retValue = false; logger.Debug(string.Format("Errore in Documentum.AddDocumentInFolder:\n{0}", ex.ToString())); } logger.Info("END"); return(retValue); }