/// <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>
///
/// </summary>
/// <returns></returns>
protected IQueryService GetQueryServiceInstance()
{
if (this._queryServiceInstance == null)
{
this._queryServiceInstance = DctmServiceFactory.GetServiceInstance <IQueryService>(this.InfoUtente.dst);
}
return(this._queryServiceInstance);
}
/// <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>
/// 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>
/// 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>
/// 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>
/// Conta il numero di gruppi di appartenenza per un utente DCTM
/// </summary>
/// <param name="userId"></param>
/// <returns></returns>
public int CountGroupsByUser(string userId)
{
IQueryService queryServices = DctmServiceFactory.GetServiceInstance <IQueryService>(UserManager.ImpersonateSuperUser());
return(Dfs4DocsPa.countGroupsByUserId(userId, queryServices));
}
/// <summary>
/// Verifica dell'esistenza del gruppo in DCTM
/// </summary>
/// <param name="groupName"></param>
/// <returns></returns>
public bool ContainsGroup(string groupName)
{
IQueryService queryServices = DctmServiceFactory.GetServiceInstance <IQueryService>(UserManager.ImpersonateSuperUser());
return(Dfs4DocsPa.containsGroup(groupName, queryServices));
}
/////// <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>
///
/// </summary>
/// <param name="idSottofascicolo"></param>
/// <returns></returns>
public bool ContainsSottofascicolo(string idSottofascicolo)
{
IQueryService queryService = DctmServiceFactory.GetServiceInstance <IQueryService>(UserManager.ImpersonateSuperUser());
return(Dfs4DocsPa.containsSottofascicolo(idSottofascicolo, queryService));
}
/// <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));
}
/// <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>
/// 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>
/// Verifica dell'esistenza dell'utente in DCTM
/// </summary>
/// <param name="userId"></param>
/// <returns></returns>
public bool ContainsUser(string userId)
{
IQueryService queryServices = DctmServiceFactory.GetServiceInstance <IQueryService>(UserManager.ImpersonateSuperUser());
return(Dfs4DocsPa.containsUser(userId, queryServices));
}
/// <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>
/// 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);
}
/// <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>
/// Reperimento dell'utente creatore di un fascicolo in DCTM
/// </summary>
/// <param name="idFascicolo"></param>
/// <param name="ownerRole"></param>
/// <returns></returns>
protected virtual void GetOwnershipFascicolo(string idFascicolo, out string ownerUser)
{
IQueryService queryService = DctmServiceFactory.GetServiceInstance <IQueryService>(this.InfoUtente.dst);
Dfs4DocsPa.getOwnershipFascicolo(idFascicolo, out ownerUser, queryService);
}