/// <summary>
///
/// </summary>
/// <param name="idPeople"></param>
/// <param name="idGruppo"></param>
/// <returns></returns>
public EsitoOperazione EliminaUtenteDaRuolo(string idPeople, string idGruppo)
{
// Eliminazione utente in un ruolo nel documentale ETDOCS
EsitoOperazione result = this.OrganigrammaManagerETDOCS.EliminaUtenteDaRuolo(idPeople, idGruppo);
if (result.Codice == 0)
{
// Eliminazione utente in un ruolo nel documentale OCS
result = this.OrganigrammaManagerOCS.EliminaUtenteDaRuolo(idPeople, idGruppo);
}
return(result);
}
/// <summary>
/// Elimina un utente in amministrazione
/// </summary>
/// <param name="utente"></param>
/// <returns></returns>
public EsitoOperazione EliminaUtente(OrgUtente utente)
{
// Eliminazione utente nel documentale ETDOCS
EsitoOperazione result = this.OrganigrammaManagerETDOCS.EliminaUtente(utente);
if (result.Codice == 0)
{
// Eliminazione utente dal GRUPPO degli utenti OCS
result = this.OrganigrammaManagerOCS.EliminaUtente(utente);
}
return(result);
}
/// <summary>
/// Inserimento di un utente in un ruolo
/// </summary>
/// <param name="idPeople"></param>
/// <param name="idGruppo"></param>
/// <returns></returns>
public EsitoOperazione InserisciUtenteInRuolo(string idPeople, string idGruppo)
{
// Inserimento utente in un ruolo nel documentale ETDOCS
EsitoOperazione result = this.OrganigrammaManagerETDOCS.InserisciUtenteInRuolo(idPeople, idGruppo);
if (result.Codice == 0)
{
// Inserimento utente in un ruolo nel documentale OCS
result = this.OrganigrammaManagerOCS.InserisciUtenteInRuolo(idPeople, idGruppo);
}
return(result);
}
/// <summary>
/// Cancellazione di un ruolo in amministrazione
/// </summary>
/// <param name="ruolo"></param>
/// <returns></returns>
public EsitoOperazione EliminaRuolo(OrgRuolo ruolo)
{
// Eliminazione del ruolo nel documentale DOCUMENTUM
EsitoOperazione result = this.OrganigrammaManagerDCTM.EliminaRuolo(ruolo);
if (result.Codice == 0)
{
// Eliminazione del ruolo nel documentale ETDOCS se è stato cancellato con successo da et docs
result = this.OrganigrammaManagerETDOCS.EliminaRuolo(ruolo);
}
return(result);
}
/// <summary>
/// Inserimento di un nuovo utente in amministrazione
/// </summary>
/// <param name="utente"></param>
/// <returns></returns>
public EsitoOperazione InserisciUtente(OrgUtente utente)
{
// Inserimento utente nel documentale ETDOCS
EsitoOperazione result = this.OrganigrammaManagerETDOCS.InserisciUtente(utente);
if (result.Codice == 0)
{
// Inserimento utente in un ruolo nel documentale OCS
result = this.OrganigrammaManagerOCS.InserisciUtente(utente);
}
return(result);
}
/// <summary>
/// Spostamento di un ruolo in amministrazione
/// </summary>
/// <param name="ruolo"></param>
/// <returns></returns>
public EsitoOperazione SpostaRuolo(OrgRuolo ruolo)
{
// Spostamento del ruolo nel documentale ETDOCS
EsitoOperazione result = this.OrganigrammaManagerETDOCS.SpostaRuolo(ruolo);
if (result.Codice == 0)
{
// Spostamento del ruolo nel documentale DCTM
result = this.OrganigrammaManagerDCTM.SpostaRuolo(ruolo);
}
return(result);
}
/// <summary>
///
/// </summary>
/// <param name="copyVisibility"></param>
/// <param name="infoUtente"></param>
/// <returns></returns>
public EsitoOperazione CopyVisibility(DocsPaVO.utente.InfoUtente infoUtente, DocsPaVO.Security.CopyVisibility copyVisibility)
{
// Copia visibilità da ruolo a ruolo nel documentale ETDOCS
EsitoOperazione result = this.OrganigrammaManagerETDOCS.CopyVisibility(infoUtente, copyVisibility);
if (result.Codice == 0)
{
// Copia visibilità da ruolo a ruolo nel documentale OCS
result = this.OrganigrammaManagerOCS.CopyVisibility(infoUtente, copyVisibility);
}
return(result);
}
/// <summary>
/// Cancellazione di un ruolo in amministrazione
/// </summary>
/// <param name="ruolo"></param>
/// <returns></returns>
public EsitoOperazione EliminaRuolo(OrgRuolo ruolo)
{
// Eliminazione del ruolo nel documentale ETDOCS
EsitoOperazione result = this.OrganigrammaManagerETDOCS.EliminaRuolo(ruolo);
if (result.Codice == 0)
{
// Se l'eliminazione è andata a buon fine,
// eliminazione del ruolo nel documentale OCS
result = this.OrganigrammaManagerOCS.EliminaRuolo(ruolo);
}
return(result);
}
/// <summary>
/// Elimina un utente in amministrazione
/// </summary>
/// <param name="utente"></param>
/// <returns></returns>
public EsitoOperazione EliminaUtenteAmm(OrgUtente utente)
{
EsitoOperazione ret = new EsitoOperazione();
string logMsg;
IObjectService objSrvc = null;
String repositoryName = DctmConfigurations.GetRepositoryName();
// test sui campi obbligatori
if (string.IsNullOrEmpty(utente.UserId))
{
logMsg = ERR_HEADER + "EliminaUtente: dati insufficienti";
ret.Codice = -1;
ret.Descrizione = logMsg;
logger.Debug(logMsg);
return(ret);
}
try
{
// verifica se esistono più di un'occorrenza per utente
if (CountGroupsByUser(utente.UserId) > 1)
{
// rimuove l'utente dal gruppo di root
EliminaUtenteDaRuoloAmm(utente.UserId, utente.IDAmministrazione);
}
else
{
ObjectIdentitySet identitySet = new ObjectIdentitySet();
objSrvc = this.GetObjectServiceInstance();
ObjectIdentity userIdentity = Dfs4DocsPa.getUserIdentityByName(TypeUtente.getUserName(utente));
// Cancellazione dell'home cabinet per l'utente
identitySet.AddIdentity(Dfs4DocsPa.getUserHomeFolderIdentity(utente.UserId));
identitySet.AddIdentity(userIdentity);
OperationOptions opts = new OperationOptions();
opts.DeleteProfile = new DeleteProfile();
opts.DeleteProfile.IsPopulateWithReferences = true;
objSrvc.Delete(identitySet, opts);
logger.Debug(DEBUG_HEADER + "EliminaUtente completata con SUCCESSO");
}
return(ret);
}
catch (Exception ex)
{
String st = ex.ToString();
logger.Debug(DEBUG_HEADER + "EliminaUtente FALLITA, Exception=" + st);
ret.Codice = -1;
ret.Descrizione = ERR_HEADER + "EliminaUtente";
return(ret);
}
}
/// <summary>
/// Implementazione della logica del task di migrazione dati
/// per tutti i ruoli di una singola amministrazione DocsPa
/// </summary>
/// <param name="infoUtente"></param>
/// <param name="amministrazione"></param>
public static void ImportaRuoli(InfoUtente infoUtente, InfoAmministrazione amministrazione, out List <string> ruoliImportati)
{
ruoliImportati = new List <string>();
// 1. Reperimento ruoli dell'amministrazione
OrgRuolo[] roles = GetRuoli(infoUtente, amministrazione);
if (roles.Length > 0)
{
Log.GetInstance(amministrazione).Write(string.Format("Reperimento dei ruoli dell'amministrazione. Numero ruoli: {0}", roles.Length.ToString()), false);
// 2. Import di ciascun ruolo in DCTM
DocsPaDocumentale_DOCUMENTUM.Documentale.OrganigrammaManager organigrammaManager = new DocsPaDocumentale_DOCUMENTUM.Documentale.OrganigrammaManager(infoUtente);
foreach (OrgRuolo role in roles)
{
// 3. Verifica esistenza ruolo
if (organigrammaManager.ContainsGroup(role.Codice))
{
Log.GetInstance(amministrazione).Write(string.Format("Ruolo '{0}' già esistente", role.Codice), false);
}
else
{
EsitoOperazione result = organigrammaManager.InserisciRuolo(role, false);
if (result.Codice == RESULT_CODE_OK)
{
Log.GetInstance(amministrazione).Write(string.Format("Migrazione ruolo '{0}'", role.Codice), false);
ruoliImportati.Add(role.Codice);
}
else
{
// 2a. Errore nell'import del ruolo (migrazione interrotta)
throw new ApplicationException(
string.Format("Si è verificato un errore nell'import del ruolo '{0}' per l'amministrazione '{1}'. Codice: {2} - Descrizione: {3}",
role.Codice, amministrazione.Codice, result.Codice.ToString(), result.Descrizione)
);
}
}
}
}
else
{
// 1a. Errore nella migrazione dei ruoli (migrazione interrotta)
throw new ApplicationException(
string.Format("Si è verificato un errore nell'import dei ruoli per l'amministrazione '{0}'. Descrizione: Nessun ruolo trovato",
amministrazione.Codice));
}
}
/// <summary>
/// Elimina un utente in amministrazione
/// </summary>
/// <param name="utente"></param>
/// <returns></returns>
public EsitoOperazione EliminaUtente(OrgUtente utente)
{
// Eliminazione utente nel documentale ETDOCS
EsitoOperazione result = this.OrganigrammaManagerETDOCS.EliminaUtente(utente);
/*
* if (result.Codice == 0)
* {
* // Eliminazione utente nel documentale DOCUMENTUM
* result = this.OrganigrammaManagerDCTM.EliminaUtente(utente);
* }
*/
return(result);
}
/// <summary>
/// Inserimento nuovo ruolo in amministrazione
/// </summary>
/// <param name="ruolo"></param>
/// <returns></returns>
public EsitoOperazione InserisciRuolo(OrgRuolo ruolo, bool computeAtipicita)
{
// Inserimento del ruolo nel documentale ETDOCS
EsitoOperazione result = this.OrganigrammaManagerETDOCS.InserisciRuolo(ruolo, computeAtipicita);
if (result.Codice == 0)
{
// Se l'inserimento è andato a buon fine,
// inserimento del ruolo nel documentale DOCUMENTUM
result = this.OrganigrammaManagerDCTM.InserisciRuolo(ruolo, computeAtipicita);
}
return(result);
}
/// <summary>
/// Modifica dei metadati di un ruolo
/// </summary>
/// <param name="ruolo"></param>
/// <returns></returns>
public EsitoOperazione ModificaRuolo(OrgRuolo ruolo)
{
// Modifica del ruolo nel documentale ETDOCS
EsitoOperazione result = this.OrganigrammaManagerETDOCS.ModificaRuolo(ruolo);
if (result.Codice == 0)
{
// Se la modifica è andata a buon fine,
// modifica del ruolo nel documentale DOCUMENTUM
result = this.OrganigrammaManagerDCTM.ModificaRuolo(ruolo);
}
return(result);
}
/// <summary>
/// Inserimento di un utente in un ruolo
/// </summary>
/// <param name="idPeople"></param>
/// <param name="idGruppo"></param>
/// <returns></returns>
public EsitoOperazione InserisciUtenteInRuolo(string idPeople, string idGruppo)
{
// Inserimento utente in un ruolo nel documentale ETDOCS
EsitoOperazione result = this.OrganigrammaManagerETDOCS.InserisciUtenteInRuolo(idPeople, idGruppo);
/*
* if (result.Codice == 0)
* {
* // Inserimento utente in un ruolo nel documentale DOCUMENTUM
* result = this.OrganigrammaManagerDCTM.InserisciUtenteInRuolo(idPeople, idGruppo);
* }
*/
return(result);
}
/// <summary>
///
/// </summary>
/// <param name="idPeople"></param>
/// <param name="idGruppo"></param>
/// <returns></returns>
public EsitoOperazione EliminaUtenteDaRuolo(string idPeople, string idGruppo)
{
// Eliminazione utente in un ruolo nel documentale ETDOCS
EsitoOperazione result = this.OrganigrammaManagerETDOCS.EliminaUtenteDaRuolo(idPeople, idGruppo);
/*
* if (result.Codice == 0)
* {
* // Eliminazione utente in un ruolo nel documentale DOCUMENTUM
* result = this.OrganigrammaManagerDCTM.EliminaUtenteDaRuolo(idPeople, idGruppo);
* }
*/
return(result);
}
/// <summary>
/// Cancellazione di un ruolo in amministrazione
/// </summary>
/// <param name="ruolo"></param>
/// <returns></returns>
public EsitoOperazione EliminaRuolo(OrgRuolo ruolo)
{
EsitoOperazione ret = new EsitoOperazione();
string logMsg;
// test sui campi obbligatori
if (string.IsNullOrEmpty(ruolo.Codice))
{
logMsg = ERR_HEADER + "EliminaRuolo: dati insufficienti";
ret.Codice = -1;
ret.Descrizione = logMsg;
logger.Debug(logMsg);
return(ret);
}
try
{
CorteContentServices.GroupDefinitionRequestType groupReq = new CorteContentServices.GroupDefinitionRequestType();
CorteContentServices.ResultType result;
groupReq.userCredentials = OCSServices.OCSUtils.getApplicationUserCredentials();
groupReq.groupDefinition = new CorteContentServices.GroupDefinitionType();
groupReq.groupDefinition.name = ruolo.Codice;
groupReq.groupDefinition.description = ruolo.Descrizione;
result = this.WsGroupInstance.DeleteGroup(groupReq);
if (OCSUtils.isValidServiceResult(result))
{
logger.Debug(DEBUG_HEADER + "EliminaRuolo completata con SUCCESSO");
ret.Codice = 0;
}
else
{
logger.Debug(DEBUG_HEADER + "EliminaRuolo operazione con ERRORE su OCS: " + result.message);
ret.Codice = -1;
ret.Descrizione = result.message.Replace("'", " ");
}
return(ret);
}
catch (Exception ex)
{
String st = ex.ToString();
logger.Debug(DEBUG_HEADER + "EliminaRuolo FALLITA, Exception=" + st);
ret.Codice = -1;
ret.Descrizione = ERR_HEADER + "EliminaRuolo";
return(ret);
}
}
/// <summary>
/// Cancellazione di un'amministrazione nel documentale
/// </summary>
/// <param name="info"></param>
/// <returns></returns>
public EsitoOperazione Delete(InfoAmministrazione info)
{
// Prima della cancellazione in etdocs, è necessario
// reperire i gruppi docspa e passarli successivamente a documentum
string[] docspaGroups = this.GetGroupNames(info.IDAmm);
EsitoOperazione retValue = this.InstanceETDOCS.Delete(info);
if (retValue.Codice == 0)
{
retValue = ((DocsPaDocumentale_DOCUMENTUM.Documentale.AmministrazioneManager) this.InstanceDCTM).Delete(info, docspaGroups);
}
return(retValue);
}
/// <summary>
/// Cancellazione di un'amministrazione nel documentale
/// </summary>
/// <param name="info"></param>
/// <returns></returns>
public EsitoOperazione Delete(InfoAmministrazione info)
{
// Prima della cancellazione in etdocs, è necessario
// reperire i gruppi docspa e passarli successivamente a OCS
DocsPaVO.amministrazione.OrgRuolo[] adminRoles = DocsPaDocumentale_OCS.DocsPaServices.DocsPaQueryHelper.getAdminGroups(info.IDAmm);
EsitoOperazione retValue = this.InstanceETDOCS.Delete(info);
if (retValue.Codice == 0)
{
retValue = ((DocsPaDocumentale_OCS.Documentale.AmministrazioneManager) this.InstanceOCS).Delete(info, adminRoles);
}
return(retValue);
}
/// <summary>
///
/// </summary>
/// <param name="utente"></param>
/// <returns></returns>
public EsitoOperazione EliminaUtente(OrgUtente utente)
{
EsitoOperazione result = this.InstanceETDOCS.EliminaUtente(utente);
if (result.Codice == 0)
{
UserManager userManager = new UserManager();
if (!userManager.DisableUserFilenet(utente.UserId))
{
result.Codice = 1;
result.Descrizione = "si è verificato un errore: eliminazione utente in FILENET";
}
}
return(result);
}
/// <summary>
/// Inserimento di un nuovo utente in amministrazione. L'utente verrà inserito in un gruppo che contiene tutti gli utenti DocsPA.
/// il gruppo deve già esistere su OCS!!!
/// </summary>
/// <param name="utente"></param>
/// <returns></returns>
public EsitoOperazione InserisciUtente(OrgUtente utente)
{
//inserisce l'utente nel gruppo dei lettori DocsPA
EsitoOperazione ret = new EsitoOperazione();
try
{
string codiceRuolo = OCSConfigurations.GetGroupUsers();
string codiceUtente = utente.CodiceRubrica;
CorteContentServices.GroupRequestType groupReq = new CorteContentServices.GroupRequestType();
CorteContentServices.ResultType result;
groupReq.userCredentials = OCSServices.OCSUtils.getApplicationUserCredentials();
groupReq.group = new CorteContentServices.GroupType();
groupReq.group.name = codiceRuolo;
//bisogna specificare la descrizione perchè l'elemento non è facoltativo al momento
groupReq.group.description = "";
groupReq.group.users = new CorteContentServices.UserType[1];
groupReq.group.users[0] = new CorteContentServices.UserType();
groupReq.group.users[0].userId = codiceUtente;
result = this.WsGroupInstance.AddGroupUsers(groupReq);
if (OCSUtils.isValidServiceResult(result))
{
logger.Debug(DEBUG_HEADER + "Inserimento utente nel gruppo DocsPa: " + codiceRuolo + " completata con SUCCESSO");
ret.Codice = 0;
}
else
{
logger.Debug(DEBUG_HEADER + "Inserimento utente nel gruppo DocsPa: " + codiceRuolo + " operazione con ERRORE");
ret.Codice = -1;
ret.Descrizione = "problema su OCS: " + result.message.Replace("'", " ");
}
return(ret);
}
catch (Exception ex)
{
String st = ex.ToString();
logger.Debug(DEBUG_HEADER + "InserisciUtenteInRuolo FALLITA, Exception=" + st);
ret.Codice = -1;
ret.Descrizione = ERR_HEADER + "InserisciUtenteInRuolo";
return(ret);
}
//throw new NotSupportedException("InserisciUtente: operazione non supportata in OCS");
}
public EsitoOperazione CalcolaAtipicita(OrgRuolo ruolo, string idTipoRuoloVecchio, string idVecchiaUo, bool calcolaSuiSottoposti)
{
EsitoOperazione result = new EsitoOperazione();
DocsPaDB.Query_DocsPAWS.Amministrazione amm = new DocsPaDB.Query_DocsPAWS.Amministrazione();
if (!amm.CalcolaAtipicita(ruolo, idTipoRuoloVecchio, idVecchiaUo, calcolaSuiSottoposti))
{
result = new EsitoOperazione()
{
Codice = -1, Descrizione = "Errore durante il calcolo di atipicità"
}
}
;
return(result);
}
}
/// <summary>
/// Implementazione della logica del task di migrazione dati
/// per tutti gli utenti di una singola amministrazione DocsPa
/// </summary>
/// <param name="infoUtente"></param>
/// <param name="amministrazione"></param>
public static void ImportaUtenti(InfoUtente infoUtente, InfoAmministrazione amministrazione)
{
// 1. Reperimento utenti dell'amministrazione
OrgUtente[] users = GetUtenti(infoUtente, amministrazione);
if (users.Length > 0)
{
Log.GetInstance(amministrazione).Write(string.Format("Reperimento degli utenti dell'amministrazione. Numero utenti: {0}", users.Length.ToString()), false);
DocsPaDocumentale_DOCUMENTUM.Documentale.OrganigrammaManager organigrammaManager = new DocsPaDocumentale_DOCUMENTUM.Documentale.OrganigrammaManager(infoUtente);
foreach (OrgUtente user in users)
{
// 2. Verifica esistenza utente
if (organigrammaManager.ContainsUser(user.UserId))
{
Log.GetInstance(amministrazione).Write(string.Format("Utente '{0}' già esistente", user.UserId), false);
}
else
{
// 3. Impostazione password di tipo amministratore per l'utente
Log.GetInstance(amministrazione).Write(string.Format("Impostazione password di tipo amministratore per l'utente '{0}'. Nuova password: '******'", user.UserId, DEFAULT_USER_PASSWORD), false);
user.Password = DEFAULT_USER_PASSWORD;
// 4. Import di ciascun utente in DCTM
EsitoOperazione result = organigrammaManager.InserisciUtente(user);
if (result.Codice == RESULT_CODE_OK)
{
Log.GetInstance(amministrazione).Write(string.Format("Migrazione utente '{0}'", user.UserId), false);
}
else
{
// 3a. Errore nell'import dell'utente (migrazione interrotta)
throw new ApplicationException(string.Format("Si è verificato un errore nell'import dell'utente '{0}' per l'amministrazione '{1}'. Codice: {2} - Descrizione: {3}", user.UserId, amministrazione.Codice, result.Codice.ToString(), result.Descrizione));
}
}
}
}
else
{
// 1a. Errore nella migrazione degli utenti (migrazione interrotta)
throw new ApplicationException(string.Format("Si è verificato un errore nell'import degli utenti per l'amministrazione '{0}'. Descrizione: Nessun utente trovato", amministrazione.Codice));
}
}
/// <summary>
/// Metodo per l'estensione di visibilità ai ruoli superiori di un ruolo
/// </summary>
/// <param name="idAmm">Id dell'amministrazione</param>
/// <param name="idGroup">Id del gruppo di cui estendere la visibilità</param>
/// <param name="extendScope">Scope di estensione</param>
/// <param name="copyIdToTempTable">True se bisogna copiare gli id id dei documenti e fascicoli in una tabella tamporanea per l'allineamento asincrono della visibilità</param>
/// <returns>Esito dell'operazione</returns>
public EsitoOperazione ExtendVisibilityToHigherRoles(
String idAmm,
String idGroup,
DocsPaVO.amministrazione.SaveChangesToRoleRequest.ExtendVisibilityOption extendScope)
{
EsitoOperazione retVal = new EsitoOperazione();
using (DocsPaDB.Query_DocsPAWS.Documentale doc = new DocsPaDB.Query_DocsPAWS.Documentale())
{
bool result = doc.ExtendVisibilityToHigherRoles(idAmm, idGroup, extendScope, false);
retVal.Codice = result ? 0 : -1;
retVal.Descrizione = result ? String.Empty : "Si è verificato un errore durante l'estensione della visibilità di documenti e fascicoli ai superiori gerarchici";
}
return(retVal);
}
/// <summary>
/// Eliminazione di un utente da un ruolo
/// </summary>
/// <param name="idPeople"></param>
/// <param name="idGruppo"></param>
/// <returns></returns>
public EsitoOperazione EliminaUtenteDaRuolo(string idPeople, string idGruppo)
{
EsitoOperazione ret = new EsitoOperazione();
try
{
string codiceRuolo = DocsPaServices.DocsPaQueryHelper.getCodiceRuoloFromIdGroup(idGruppo);
string codiceUtente = DocsPaServices.DocsPaQueryHelper.getCodiceUtente(idPeople);
CorteContentServices.GroupRequestType groupReq = new CorteContentServices.GroupRequestType();
CorteContentServices.ResultType result;
groupReq.userCredentials = OCSServices.OCSUtils.getApplicationUserCredentials();
groupReq.group = new CorteContentServices.GroupType();
groupReq.group.name = codiceRuolo;
//bisogna specificare la descrizione perchè l'elemento non è facoltativo al momento
groupReq.group.description = "";
groupReq.group.users = new CorteContentServices.UserType[1];
groupReq.group.users[0] = new CorteContentServices.UserType();
groupReq.group.users[0].userId = codiceUtente;
result = this.WsGroupInstance.RemoveGroupUsers(groupReq);
if (OCSUtils.isValidServiceResult(result))
{
logger.Debug(DEBUG_HEADER + "EliminaUtenteDaRuolo completata con SUCCESSO");
ret.Codice = 0;
}
else
{
logger.Debug(DEBUG_HEADER + "EliminaUtenteDaRuolo operazione con ERRORE su OCS: " + result.message);
ret.Codice = -1;
ret.Descrizione = "Errore in OCS: " + result.message.Replace("'", " ");
}
return(ret);
}
catch (Exception ex)
{
String st = ex.ToString();
logger.Debug(DEBUG_HEADER + "EliminaUtenteDaRuolo FALLITA, Exception=" + st);
ret.Codice = -1;
ret.Descrizione = ERR_HEADER + "EliminaUtenteDaRuolo";
return(ret);
}
}
/// <summary>
/// Inserimento di un nuovo nodo di titolario
/// </summary>
/// <param name="nodoTitolario"></param>
/// <returns></returns>
public bool SaveNodoTitolario(OrgNodoTitolario nodoTitolario)
{
bool saved = false;
using (DocsPaDB.Query_DocsPAWS.Amministrazione amm = new DocsPaDB.Query_DocsPAWS.Amministrazione())
{
if (string.IsNullOrEmpty(nodoTitolario.ID))
{
EsitoOperazione esito = amm.InsertNodoTitolario(ref nodoTitolario);
saved = (esito.Codice == 0);
}
else
{
saved = amm.UpdateNodoTitolario(nodoTitolario);
}
}
return(saved);
}
/// <summary>
///
/// </summary>
/// <param name="utente"></param>
/// <returns></returns>
public EsitoOperazione InserisciUtente(OrgUtente utente)
{
EsitoOperazione result = this.InstanceETDOCS.InserisciUtente(utente);
if (result.Codice == 0)
{
UserManager userManager = new UserManager();
string defaultFNETGroup = System.Configuration.ConfigurationManager.AppSettings["FNET_userGroup"];
bool retValue = userManager.AddUserFilenet(utente.UserId, utente.Password, utente.IDAmministrazione, string.Format("{0} {1}", utente.Cognome, utente.Nome), defaultFNETGroup);
if (!retValue)
{
result.Codice = 9;
result.Descrizione = "si è verificato un errore: inserimento nuovo utente in FILENET";
}
}
return(result);
}
/// <summary>
///
/// </summary>
/// <param name="utente"></param>
/// <returns></returns>
public EsitoOperazione ModificaUtente(OrgUtente utente)
{
// memorizzo la vecchia PWD per Filenet
DocsPaDB.Query_DocsPAWS.Utenti user = new DocsPaDB.Query_DocsPAWS.Utenti();
string oldPwdFileNet = user.GetPasswordUserFilenet(utente.UserId);
EsitoOperazione result = this.InstanceETDOCS.ModificaUtente(utente);
if (result.Codice == 0)
{
UserManager userManager = new UserManager();
bool retValue = userManager.UpdateUserFilenet(utente.UserId, oldPwdFileNet, utente.Password, string.Format("{0} {1}", utente.Cognome, utente.Nome), utente.IDAmministrazione);
if (!retValue)
{
result.Codice = 10;
result.Descrizione = "si è verificato un errore: modifica dati utente in FILENET";
}
}
return(result);
}
/// <summary>
/// Cancellazione di un ruolo in amministrazione
/// </summary>
/// <param name="ruolo"></param>
/// <returns></returns>
public EsitoOperazione EliminaRuolo(OrgRuolo ruolo)
{
EsitoOperazione ret = new EsitoOperazione();
string logMsg;
IObjectService objSrvc = null;
String repositoryName = DctmConfigurations.GetRepositoryName();
// test sui campi obbligatori
if (string.IsNullOrEmpty(ruolo.Codice))
{
logMsg = ERR_HEADER + "EliminaRuolo: dati insufficienti";
ret.Codice = -1;
ret.Descrizione = logMsg;
logger.Debug(logMsg);
return(ret);
}
try
{
objSrvc = this.GetObjectServiceInstance();
ObjectIdentity groupIdentity = Dfs4DocsPa.getGroupIdentityByName(TypeGruppo.GetGroupName(ruolo));
checkReference(TypeGruppo.GetGroupName(ruolo), ObjectTypes.UTENTE, "user_group_name", false);
ObjectIdentitySet s = new ObjectIdentitySet(groupIdentity);
objSrvc.Delete(s, null);
logger.Debug(DEBUG_HEADER + "EliminaRuolo completata con SUCCESSO");
return(ret);
}
catch (Exception ex)
{
String st = ex.ToString();
logger.Debug(DEBUG_HEADER + "EliminaRuolo FALLITA, Exception=" + st);
ret.Codice = -1;
ret.Descrizione = ERR_HEADER + "EliminaRuolo";
return(ret);
}
}
/// <summary>
///
/// </summary>
/// <param name="infoUtente"></param>
/// <param name="copyVisibility"></param>
/// <returns></returns>
public EsitoOperazione CopyVisibility(DocsPaVO.utente.InfoUtente infoUtente, DocsPaVO.Security.CopyVisibility copyVisibility)
{
EsitoOperazione esitoOperazione = new EsitoOperazione();
using (DocsPaDB.TransactionContext transactionContext = new DocsPaDB.TransactionContext())
{
try
{
DocsPaDB.Query_DocsPAWS.Documentale documentale = new DocsPaDB.Query_DocsPAWS.Documentale();
esitoOperazione = documentale.CopyVisibility(infoUtente, copyVisibility);
transactionContext.Complete();
return(esitoOperazione);
}
catch (Exception e)
{
logger.Debug("Errore in OrganigrammaManager - metodo: CopyVisibility", e);
esitoOperazione.Codice = -1;
esitoOperazione.Descrizione = "Problemi durante la copia della visibilità ETDOCS. Cosultare il file di log.";
return(esitoOperazione);
}
}
}
/// <summary>
/// Aggiornamento dei dati della password di tipo amministratore per l'utente
/// </summary>
/// <param name="esito"></param>
/// <param name="utente"></param>
protected void UpdatePasswordData(EsitoOperazione esito, OrgUtente utente)
{
AdminPasswordConfig pwdConfig = new AdminPasswordConfig();
if (pwdConfig.IsSupportedPasswordConfig())
{
int idAmministrazione = Convert.ToInt32(utente.IDAmministrazione);
if (!string.IsNullOrEmpty(utente.Password))
{
// Se l'inserimento dell'utente è andato a buon fine,
// viene inserita la password di tipo amministratore
// (solo se supportata la configurazione password)
DocsPaVO.Validations.ValidationResultInfo ret =
DocsPaPwdServices.UserPasswordServices.SetPassword(idAmministrazione, utente.UserId, utente.Password, true);
if (!ret.Value)
{
esito.Codice = 9;
esito.Descrizione = ret.BrokenRules[0].ToString();
}
}
if (esito.Codice == 0)
{
try
{
// Aggiornamento valore per flag "Nessuna scadenza password"
DocsPaPwdServices.UserPasswordServices.SetPasswordNeverExpireOption(utente.NessunaScadenzaPassword, utente.UserId);
}
catch
{
esito.Codice = 9;
esito.Descrizione = "Errore nella modifica dei dati della password";
}
}
}
}
