/// <summary>
/// Reperimento di tutti i tipi funzione disponibili
/// </summary>
/// <param name="fillFunzioniElementari">Specifica se caricare o meno le funzioni elementari</param>
/// <returns></returns>
public static OrgTipoFunzione[] GetTipiFunzione(bool fillFunzioniElementari, string idAmm)
{
ArrayList retValue = new ArrayList();
DocsPaUtils.Query queryDef = DocsPaUtils.InitQuery.getInstance().getQuery("AMM_S_GET_TIPI_FUNZIONE");
queryDef.setParam("idAmm", idAmm);
string commandText = queryDef.getSQL();
logger.Debug(commandText);
using (DocsPaDB.DBProvider dbProvider = new DocsPaDB.DBProvider())
{
using (System.Data.IDataReader reader = dbProvider.ExecuteReader(commandText))
{
while (reader.Read())
{
DocsPaVO.amministrazione.OrgTipoFunzione tipoFunzione = CreateTipoFunzione(reader);
if (fillFunzioniElementari)
{
tipoFunzione.Funzioni = FunzioniManager.GetFunzioni(tipoFunzione.IDTipoFunzione);
}
retValue.Add(tipoFunzione);
}
}
}
return((OrgTipoFunzione[])retValue.ToArray(typeof(OrgTipoFunzione)));
}
/// <summary>
/// Inserimento / aggiornamento funzioni elementari,solo se modificate
/// </summary>
/// <param name="dbProvider"></param>
/// <param name="funzioni"></param>
/// <returns></returns>
private static bool UpdateFunzioniElementari(DBProvider dbProvider, DocsPaVO.amministrazione.OrgTipoFunzione tipoFunzione)
{
bool retValue = true;
foreach (OrgFunzione funzione in tipoFunzione.Funzioni)
{
if (funzione.StatoFunzione != OrgFunzione.StatoOrgFunzioneEnum.Unchanged)
{
funzione.IDTipoFunzione = tipoFunzione.IDTipoFunzione;
retValue = FunzioniManager.Update(dbProvider, funzione);
if (!retValue)
{
break;
}
}
}
return(retValue);
}
/// <summary>
/// Verifica univocità codice tipo funzione
/// </summary>
/// <returns></returns>
private static bool ContainsCodiceTipoFunzione(DocsPaVO.amministrazione.OrgTipoFunzione tipoFunzione)
{
bool retValue = false;
DocsPaUtils.Query queryDef = DocsPaUtils.InitQuery.getInstance().getQuery("AMM_S_CONTAINS_CODICE_TIPO_FUNZIONE");
queryDef.setParam("codiceTipoFunzione", tipoFunzione.Codice);
queryDef.setParam("idAmm", tipoFunzione.IDAmministrazione);
string commandText = queryDef.getSQL();
logger.Debug(commandText);
using (DBProvider dbProvider = new DBProvider())
{
string outParam;
if (dbProvider.ExecuteScalar(out outParam, commandText))
{
retValue = (Convert.ToInt32(outParam) > 0);
}
}
return(retValue);
}
/// <summary>
/// Verifica se il tipo funzione è associato ad almeno un ruolo
/// </summary>
/// <param name="tipoFunzione"></param>
/// <returns></returns>
private static bool ContainsRuoli(DocsPaVO.amministrazione.OrgTipoFunzione tipoFunzione)
{
bool retValue = false;
DocsPaUtils.Query queryDef = DocsPaUtils.InitQuery.getInstance().getQuery("AMM_S_GET_COUNT_RUOLI_TIPO_FUNZIONE");
queryDef.setParam("idTipoFunzione", tipoFunzione.IDTipoFunzione);
string commandText = queryDef.getSQL();
logger.Debug(commandText);
string countRuoli;
using (DBProvider dbProvider = new DBProvider())
{
if (dbProvider.ExecuteScalar(out countRuoli, commandText))
{
retValue = (Convert.ToInt32(countRuoli) > 0);
}
}
return(retValue);
}
private static ValidationResultInfo IsValidRequiredFieldsTipoFunzione(
DBActionTypeTipoFunzioneEnum actionType,
DocsPaVO.amministrazione.OrgTipoFunzione tipoFunzione)
{
ValidationResultInfo retValue = new ValidationResultInfo();
if (actionType != DBActionTypeTipoFunzioneEnum.InsertMode &&
(tipoFunzione.IDTipoFunzione == null ||
tipoFunzione.IDTipoFunzione == string.Empty ||
tipoFunzione.IDTipoFunzione == "0"))
{
retValue.Value = false;
retValue.BrokenRules.Add(new BrokenRule("ID_TIPO_FUNZIONE", "ID tipo funzione mancante"));
}
if (actionType == DBActionTypeTipoFunzioneEnum.InsertMode ||
actionType == DBActionTypeTipoFunzioneEnum.UpdateMode)
{
if (tipoFunzione.Codice == null || tipoFunzione.Codice == string.Empty)
{
retValue.Value = false;
retValue.BrokenRules.Add(new BrokenRule("CODICE_TIPO_FUNZIONE", "Codice tipo funzione mancante"));
}
if (tipoFunzione.Descrizione == null || tipoFunzione.Descrizione == string.Empty)
{
retValue.Value = false;
retValue.BrokenRules.Add(new BrokenRule("DESCRIZIONE_TIPO_FUNZIONE", "Descrizione tipo funzione mancante"));
}
DocsPaVO.Validations.BrokenRule ruleFunzioniMancanti = new BrokenRule("FUNZIONI_MANCANTI", "Nessuna funzione elementare associata al tipo funzione");
if (tipoFunzione.Funzioni == null || tipoFunzione.Funzioni.Length == 0)
{
retValue.Value = false;
retValue.BrokenRules.Add(ruleFunzioniMancanti);
}
}
if (actionType == DBActionTypeTipoFunzioneEnum.UpdateMode)
{
DocsPaVO.Validations.BrokenRule ruleFunzioniMancanti = new BrokenRule("FUNZIONI_MANCANTI", "Nessuna funzione elementare associata al tipo funzione");
DBProvider dbProvider = new DBProvider();
try
{
dbProvider.BeginTransaction();
int functionsAssociate = 0;
DocsPaUtils.Query queryDef = DocsPaUtils.InitQuery.getInstance().getQuery("AMM_S_COUNT_FUNZ_TIPO_FUNZIONE");
queryDef.setParam("nomeTipo", tipoFunzione.Codice.ToUpper());
queryDef.setParam("idAmm", tipoFunzione.IDAmministrazione);
string commandText = queryDef.getSQL();
logger.Debug(commandText);
string parm = string.Empty;
if (dbProvider.ExecuteScalar(out parm, commandText))
//retValue.Value = dbProvider.ExecuteNonQuery(commandText, out functionsAssociate);
{
functionsAssociate = Convert.ToInt32(parm);
foreach (DocsPaVO.amministrazione.OrgFunzione funzione in tipoFunzione.Funzioni)
{
if (funzione.StatoFunzione != OrgFunzione.StatoOrgFunzioneEnum.Unchanged && !funzione.Associato)
{
functionsAssociate--;
}
}
if (functionsAssociate == 0)
{
retValue.Value = false;
retValue.BrokenRules.Add(ruleFunzioniMancanti);
}
}
}
catch
{
dbProvider.RollbackTransaction();
retValue.Value = false;
}
finally
{
dbProvider.Dispose();
dbProvider = null;
}
}
return(retValue);
}
