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>
/// Reperimento utenti in amministrazione
/// </summary>
/// <returns></returns>
private static Dictionary <string, OrgUtente> GetUsers()
{
Dictionary <string, OrgUtente> result = new Dictionary <string, OrgUtente>();
OrgUtente userError = null;
try
{
foreach (OrgUtente user in BusinessLogic.Amministrazione.OrganigrammaManager.GetUtenti())
{
userError = user;
logger.Debug("GET UTENTE PITRE utente userid " + user.UserId + " matricola " + user.Matricola + " DN " + " email " + user.Email);
try
{
result.Add(user.IdSincronizzazioneLdap.ToUpper(), user);
}
catch (Exception e)
{ }
}
}
catch (Exception ex)
{
logger.Debug("errore per utente userid " + userError.UserId + " matricola " + userError.Matricola + " " + ex.StackTrace + " " + ex.Message);
}
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)
{
#region Inserimento utente nel documentale DOCUMENTUM
//MEV Inserimento utenti multi-amministrazione su Documentum
// verifica se nuovo utente esiste su Documentum
if (this.OrganigrammaManagerDCTM.ContainsUser(utente.UserId))
{
// recupero info gruppo Amministratore
string codiceAmm = DocsPaDocumentale_DOCUMENTUM.DocsPaServices.DocsPaQueryHelper.getCodiceAmministrazione(utente.IDAmministrazione);
string gruppoAmm = DocsPaDocumentale_DOCUMENTUM.DocsPaObjectTypes.TypeGruppo.GetGroupNameForAmministrazione(codiceAmm);
// aggiunge l'utente nei ruoli di amministratore
OrganigrammaManagerDCTM.InserisciUtenteInAmm(utente);
result.Codice = 0;
result.Descrizione = string.Empty;
}
else
{
// se l'utente non esiste in nessuna amministrazione, ne crea uno nuovo
result = this.OrganigrammaManagerDCTM.InserisciUtente(utente);
}
#endregion
}
return(result);
}
/// <summary>
/// Modifica dei dati di un utente in amministrazione
/// </summary>
/// <param name="utente"></param>
/// <returns></returns>
public EsitoOperazione ModificaUtente(OrgUtente utente)
{
// Modifica utente nel documentale ETDOCS
EsitoOperazione result = this.OrganigrammaManagerETDOCS.ModificaUtente(utente);
return(result);
}
/// <summary>
/// Creazione nuovo oggetto utente in amministrazione
/// </summary>
/// <param name="ldapUser"></param>
/// <param name="idAmministrazione"></param>
/// <param name="dominio"></param>
/// <returns></returns>
private static OrgUtente CreateUser(LdapUser ldapUser, string idAmministrazione, string dominio)
{
OrgUtente user = new OrgUtente();
user.UserId = ldapUser.UserID;
user.IDAmministrazione = idAmministrazione;
user.Dominio = dominio;
if (string.IsNullOrEmpty(user.Dominio))
{
user.Password = "******";
}
user.Email = ldapUser.Email;
user.Codice = user.UserId;
user.CodiceRubrica = user.Codice;
user.Nome = ldapUser.Nome;
user.Cognome = ldapUser.Cognome;
user.Sede = ldapUser.Sede;
user.Abilitato = "1";
user.Amministratore = "0";
// Impostazione dell'id sincronizzazione in ldap
user.IdSincronizzazioneLdap = ldapUser.Matricola;
// Per default, tutti i nuovi utenti importati da un archivio LDAP
// potranno utilizzare le credenziali di dominio per connettersi al sitema
user.AutenticatoInLdap = true;
return(user);
}
public static UserInfo buildInstance(OrgUtente input)
{
UserInfo res = new UserInfo();
res.Descrizione = input.Cognome + " " + input.Nome;
res.UserId = input.UserId;
return(res);
}
/// <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);
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);
return(result);
}
/// <summary>
/// Modifica dei dati di un utente in amministrazione
/// </summary>
/// <param name="utente"></param>
/// <returns></returns>
public EsitoOperazione ModificaUtente(OrgUtente utente)
{
// Modifica utente nel documentale ETDOCS
EsitoOperazione result = this.OrganigrammaManagerETDOCS.ModificaUtente(utente);
if (result.Codice == 0 || result.Codice == 5 || result.Codice == 4 || result.Codice == 6)
{
// Modifica utente nel documentale DOCUMENTUM
result = this.OrganigrammaManagerDCTM.ModificaUtente(utente);
}
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 nel documentale DOCUMENTUM
result = this.OrganigrammaManagerDCTM.EliminaUtenteAmm(utente);
}
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 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>
/// Modifica dei dati di un utente in amministrazione
/// </summary>
/// <param name="utente"></param>
/// <returns></returns>
public EsitoOperazione ModificaUtente(OrgUtente utente)
{
// Modifica utente nel documentale ETDOCS
EsitoOperazione result = this.OrganigrammaManagerETDOCS.ModificaUtente(utente);
/*
* if (result.Codice == 0)
* {
* // Modifica utente nel documentale DOCUMENTUM
* result = this.OrganigrammaManagerDCTM.ModificaUtente(utente);
* }
*/
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>
///
/// </summary>
/// <param name="utente"></param>
/// <returns></returns>
public EsitoOperazione EliminaUtente(OrgUtente utente)
{
DocsPaVO.amministrazione.EsitoOperazione esito = new DocsPaVO.amministrazione.EsitoOperazione();
using (DocsPaDB.Query_DocsPAWS.Amministrazione dbAmm = new DocsPaDB.Query_DocsPAWS.Amministrazione())
{
if (!dbAmm.AmmEliminaUtente(utente))
{
esito.Codice = 1;
esito.Descrizione = "si è verificato un errore: eliminazione utente";
}
}
return(esito);
}
/// <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");
}
/// <summary>
/// Elimina un utente in amministrazione
/// </summary>
/// <param name="utente"></param>
/// <returns></returns>
public EsitoOperazione EliminaUtente(OrgUtente utente)
{
EsitoOperazione ret = new EsitoOperazione();
try
{
string codiceRuolo = OCSConfigurations.GetGroupUsers();
string codiceUtente = utente.UserId;
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 + "EliminaUtente completata con SUCCESSO");
ret.Codice = 0;
}
else
{
logger.Debug(DEBUG_HEADER + "EliminaUtente 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 + "EliminaUtente FALLITA, Exception=" + st);
ret.Codice = -1;
ret.Descrizione = ERR_HEADER + "EliminaUtente";
return(ret);
}
}
private void undoCreateHomeFolder(OrgUtente utente)
{
try
{
IObjectService objSrvc = this.GetObjectServiceInstance();
string homePath = "/" + TypeUtente.getHomeFolderName(utente.UserId);
ObjectIdentity homeIdentity =
new ObjectIdentity(new ObjectPath(homePath),
DctmConfigurations.GetRepositoryName());
ObjectIdentitySet idSet = new ObjectIdentitySet(homeIdentity);
objSrvc.Delete(idSet, null);
}
catch (Exception ex)
{
//se siamo arrivati qui, significa che siamo già in una condizione di errore
//non è così grave: rimane un folder, che non pregiudica un eventuale nuovo tentativo dei definire l'utente
//in ogni caso è inutile rilanciare l'eccezione: già il chiamante è in gestione di una ecc.
logger.Debug(DEBUG_HEADER + "Impossibile annullare l'inserimento dell'home folder: " + ex.ToString());
}
}
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="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);
}
private bool undoCreateUser(OrgUtente utente)
{
try
{
ObjectIdentity userIdentity = Dfs4DocsPa.getUserIdentityByName(TypeUtente.getUserName(utente));
ObjectIdentitySet idSet = new ObjectIdentitySet(userIdentity);
IObjectService objSrvc = this.GetObjectServiceInstance();
objSrvc.Delete(idSet, null);
return(true);
}
catch (Exception ex)
{
//se siamo arrivati qui, significa che siamo già in una condizione di errore
//se si verifica un'eccezione qui, siamo nei guai: non riusciamo a fare un clean
//in ogni caso è inutile rilanciare l'eccezione: già il chiamante è in gestione di una ecc.
logger.Debug(DEBUG_HEADER + "GRAVE: impossibile annullare l'inserimento utente");
return(false);
}
}
/// <summary>
///
/// </summary>
/// <param name="utente"></param>
/// <returns></returns>
public EsitoOperazione InserisciUtente(OrgUtente utente)
{
DocsPaVO.amministrazione.EsitoOperazione esito = new DocsPaVO.amministrazione.EsitoOperazione();
string result = string.Empty;
using (DocsPaDB.Query_DocsPAWS.Amministrazione dbAmm = new DocsPaDB.Query_DocsPAWS.Amministrazione())
result = dbAmm.AmmInsNuovoUtente(utente);
// possibili valori di ritorno:
// 1 - userid già presente
// 2 - codice rubrica già presente
// 9 - errore generico
// 0 - tutto ok!
switch (result)
{
case "0":
// Modifica dei dati della password
this.UpdatePasswordData(esito, utente);
break;
case "1":
esito.Codice = 1;
esito.Descrizione = "la USERID è già utilizzata da altro utente";
break;
case "2":
esito.Codice = 2;
esito.Descrizione = "il CODICE RUBRICA è già utilizzato da altro utente";
break;
case "9":
esito.Codice = 9;
esito.Descrizione = "si è verificato un errore: inserimento nuovo utente";
break;
}
return(esito);
}
/// <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";
}
}
}
}
/// <summary>
/// Aggiornamento dati utente già presente in amministrazione
/// </summary>
/// <param name="user"></param>
/// <param name="ldapUser"></param>
private static bool UpdateUserIfDirty(OrgUtente user, LdapUser ldapUser)
{
bool dirty = (user.UserId != ldapUser.UserID ||
user.Email != ldapUser.Email ||
user.Nome != ldapUser.Nome ||
user.Cognome != ldapUser.Cognome ||
user.Sede != ldapUser.Sede);
if (dirty)
{
user.UserId = ldapUser.UserID;
user.Email = ldapUser.Email;
user.Nome = ldapUser.Nome;
user.Cognome = ldapUser.Cognome;
user.Sede = ldapUser.Sede;
user.Abilitato = "1";
user.Amministratore = "0";
}
return(dirty);
}
/// <summary>
/// Creazione oggetto utente
/// </summary>
/// <param name="reader"></param>
/// <returns></returns>
private static OrgUtente GetUtente(IDataReader reader)
{
OrgUtente user = new OrgUtente();
user.IDPeople = DocsPaUtils.Data.DataReaderHelper.GetValue <object>(reader, "SYSTEM_ID", false).ToString();
logger.Debug("LEGGO UTENTI");
user.UserId = DocsPaUtils.Data.DataReaderHelper.GetValue <string>(reader, "USER_ID", false);
user.Codice = user.UserId;
user.Password = DEFAULT_USER_PASSWORD; // Password di default impostata dall'amministratore
string email = DocsPaUtils.Data.DataReaderHelper.GetValue <string>(reader, "EMAIL_ADDRESS", true);
if (string.IsNullOrEmpty(email))
{
user.Email = DEFAULT_USER_MAIL;
}
else
{
user.Email = email;
}
string disabled = DocsPaUtils.Data.DataReaderHelper.GetValue <string>(reader, "DISABLED", true);
if (!string.IsNullOrEmpty(disabled) && disabled == "N")
{
user.Abilitato = "1";
}
else
{
user.Abilitato = "0";
}
user.IDAmministrazione = DocsPaUtils.Data.DataReaderHelper.GetValue <object>(reader, "ID_AMM", true).ToString();
user.Amministratore = DocsPaUtils.Data.DataReaderHelper.GetValue <string>(reader, "CHA_AMMINISTRATORE", true);
return(user);
}
/// <summary>
///
/// </summary>
/// <param name="utente"></param>
/// <returns></returns>
public EsitoOperazione EliminaUtente(OrgUtente utente)
{
return(this.InstanceETDOCS.EliminaUtente(utente));
}
/// <summary>
/// Modifica dei dati di un utente in amministrazione
/// </summary>
/// <param name="utente"></param>
/// <returns></returns>
public EsitoOperazione ModificaUtente(OrgUtente utente)
{
throw new NotSupportedException("ModificaUtente: operazione non supportata in OCS");
}
/// <summary>
///
/// </summary>
/// <param name="utente"></param>
/// <returns></returns>
public EsitoOperazione ModificaUtente(OrgUtente utente)
{
DocsPaVO.amministrazione.EsitoOperazione esito = new DocsPaVO.amministrazione.EsitoOperazione();
string result = string.Empty;
using (DocsPaDB.Query_DocsPAWS.Amministrazione dbAmm = new DocsPaDB.Query_DocsPAWS.Amministrazione())
result = dbAmm.AmmModUtente(utente);
// possibili valori di ritorno:
// 1 - utente al momento connesso a DocsPA
// 2 - userid già presente
// 3 - codice rubrica già presente
// 9 - errore generico
// 0 - tutto ok!
switch (result)
{
case "0":
// Modifica dei dati della password
this.UpdatePasswordData(esito, utente);
if (!string.IsNullOrEmpty(utente.Password) && esito.Codice == 0)
{
esito.Codice = 4;
}
break;
case "1":
esito.Codice = 1;
esito.Descrizione = "utente connesso a DocsPA. Impossibile modificare i dati!";
break;
case "2":
esito.Codice = 1;
esito.Descrizione = "la USERID è già utilizzata da altro utente";
break;
case "3":
esito.Codice = 2;
esito.Descrizione = "il CODICE RUBRICA è già utilizzato da altro utente";
break;
case "4":
this.UpdatePasswordData(esito, utente);
if (!string.IsNullOrEmpty(utente.Password))
{
if (esito.Codice == 0)
{
esito.Codice = 6;
}
}
else
{
esito.Codice = 5;
}
break;
case "9":
esito.Codice = 9;
esito.Descrizione = "si è verificato un errore: modifica dati utente";
break;
}
return(esito);
}
