/// <summary>
/// CheckIn del documento corrente MTEXT
/// </summary>
private void CheckInMTextDocument(String file)
{
// Salvataggio del docNumber del documento in CheckOut
String docNumber = CheckOutContext.Current.Status.DocumentNumber;
// Estrai porzione del path di interesse per M/TEXT
file = file.Substring(8);
// Accedi a MTEXT per prelevare il PDF
MTextModelProvider mtext = ModelProviderFactory <MTextModelProvider> .GetInstance();
// Preleva contenuto PDF
Byte[] content = mtext.ExportDocument(file, "application/pdf");
// Fai sembrare il file M/TEXT un file FDF
CheckOutContext.Current.Status.DocumentLocation = "mtext.pdf";
// Effettua il checkin del documento
ValidationResultInfo result = CheckInOutServices.CheckInDocument(content);
// Salva l'FQN del file M/TEXT
DocsPaWebService ws = new DocsPaWebService();
ws.SetMTextFullQualifiedName(new MTextDocumentInfo()
{
DocumentDocNumber = docNumber,
FullQualifiedName = file
});
if (!result.Value)
{
// Scrittura dei messaggi di errore nel checkin
Response.Write(this.GetErrorMessage(result));
}
}
/// <summary>
/// Verifica della validità formale della password
/// </summary>
/// <param name="password"></param>
/// <param name="idAmministrazione"></param>
/// <returns></returns>
private static ValidationResultInfo CheckPasswordString(string password, int idAmministrazione)
{
ValidationResultInfo result = new ValidationResultInfo();
// Verifica della presenza di caratteri non validi
if (!CheckPasswordInvalidChars(password))
{
result.BrokenRules.Add(CreateBrokenRule("PASSWORD_INVALID_CHARS", "La password contiene caratteri non ammessi", BrokenRule.BrokenRuleLevelEnum.Error));
}
// Verifica della lunghezza della password fornita
DocsPaVO.amministrazione.PasswordConfigurations config = AdminPasswordConfigServices.GetPasswordConfigurations(idAmministrazione);
if (password.Length < config.MinLength)
{
result.BrokenRules.Add(CreateBrokenRule("PASSWORD_LENGHT", string.Format("La lunghezza della password deve essere di almeno {0} caratteri", config.MinLength.ToString()), BrokenRule.BrokenRuleLevelEnum.Error));
}
// Verifica la presenza di caratteri speciali obbligatori
if (config.SpecialCharacters.Length > 0 && password.IndexOfAny(config.SpecialCharacters) == -1)
{
result.BrokenRules.Add(CreateBrokenRule("PASSWORD_REQUIRED_SPECIAL_CHARS", string.Format("La password deve contenere almeno uno tra i seguenti caratteri speciali:{0}", " " + new string(config.SpecialCharacters)), BrokenRule.BrokenRuleLevelEnum.Error));
}
//result.BrokenRules.Add(CreateBrokenRule("PASSWORD_REQUIRED_SPECIAL_CHARS", "La password deve contenere almeno uno tra i caratteri speciali previsti in amministrazione", BrokenRule.BrokenRuleLevelEnum.Error));
return(result);
}
public Guid Save(County entity, bool?isSync = null)
{
var vri = new ValidationResultInfo();
if (isSync == null || !isSync.Value)
{
vri = Validate(entity);
}
if (!vri.IsValid)
{
throw new DomainValidationException(vri, "County not valid");
}
DateTime dt = DateTime.Now;
using (var ctx = GetVtsContext("CountyRepository"))
{
County county = GetById(entity.Id);
if (county == null)
{
entity.Status = EntityStatus.Active;
entity.DateCreated = dt;
}
entity.DateLastUpdated = dt;
ctx.UpdateGraph(entity, map => map.OwnedCollection(n => n.CountyGovernors)
.OwnedCollection(n => n.CountySenators)
.OwnedCollection(n => n.CountyWomenReps));
ctx.SaveChanges();
}
return(entity.Id);
}
public Guid Save(Ward entity, bool?isSync = null)
{
var vri = new ValidationResultInfo();
if (isSync == null || !isSync.Value)
{
vri = Validate(entity);
}
if (!vri.IsValid)
{
throw new DomainValidationException(vri, "Ward not valid");
}
DateTime dt = DateTime.Now;
using (var ctx = GetVtsContext("WardRepository"))
{
Ward ward = GetById(entity.Id);
if (ward == null)
{
entity.Status = EntityStatus.Active;
entity.DateCreated = dt;
}
entity.DateLastUpdated = dt;
ctx.UpdateGraph(entity, map => map.OwnedCollection(n => n.WardMcas));
ctx.SaveChanges();
}
return(entity.Id);
}
/// <summary>
/// Verifica vincoli in inserimento di un registro
/// </summary>
/// <param name="registro"></param>
/// <returns></returns>
public static ValidationResultInfo CanInsertRegistro(OrgRegistro registro)
{
ValidationResultInfo retValue = IsValidRequiredFieldsRegistro(DBActionTypeRegistroEnum.InsertMode, registro);
// Verifica presenza codice univoco
if (retValue.Value)
{
DocsPaDB.Query_DocsPAWS.Amministrazione dbAmministrazione = new DocsPaDB.Query_DocsPAWS.Amministrazione();
retValue.Value = dbAmministrazione.CheckUniqueCodiceRegistro(registro.Codice, registro.CodiceAmministrazione);
if (!retValue.Value)
{
BrokenRule brokenRule = new BrokenRule();
if (registro.chaRF != null && registro.chaRF != string.Empty)
{
if (registro.chaRF == "0")
{
brokenRule.ID = "CODICE_REGISTRO";
brokenRule.Description = "Codice registro già presente";
}
else
{
brokenRule.ID = "CODICE_RF";
brokenRule.Description = "Codice RF già presente";
}
}
retValue.BrokenRules.Add(brokenRule);
}
}
return(retValue);
}
public Guid Save(Race entity, bool?isSync = null)
{
var vri = new ValidationResultInfo();
if (isSync == null || !isSync.Value)
{
vri = Validate(entity);
}
if (!vri.IsValid)
{
throw new DomainValidationException(vri, "Race not valid");
}
DateTime dt = DateTime.Now;
using (var ctx = GetVtsContext("RaceRepository"))
{
Race race = GetById(entity.Id);
if (race == null)
{
entity.Status = EntityStatus.Active;
entity.DateCreated = dt;
}
entity.DateLastUpdated = dt;
ctx.UpdateGraph(entity);
ctx.SaveChanges();
}
return(entity.Id);
}
/// Verifica vincoli in inserimento di una qualifica, campi validi e univocità codice
public static ValidationResultInfo InsertQual(Qualifica qual)
{
ValidationResultInfo retValue = IsValidRequiredFieldsQualifica(DBActionTypeRegistroEnum.InsertMode, qual);
// Verifica presenza codice univoco
if (retValue.Value)
{
DocsPaDB.Query_DocsPAWS.Utenti dbUtenti = new DocsPaDB.Query_DocsPAWS.Utenti();
retValue.Value = dbUtenti.CheckUniqueCodiceQualifica(qual.CODICE, qual.ID_AMM.ToString());
if (!retValue.Value)
{
BrokenRule brokenRule = new BrokenRule();
brokenRule.ID = "CODICE_QUALIFICA";
brokenRule.Description = "Codice qualifica già presente";
retValue.BrokenRules.Add(brokenRule);
}
else
{
dbUtenti.InsertQual(qual.CODICE, qual.DESCRIZIONE, qual.ID_AMM.ToString());
retValue.Value = true;
}
}
return(retValue);
}
/// <summary>
/// CheckIn di un documento
/// </summary>
/// <param name="content"></param>
/// <returns></returns>
public static ValidationResultInfo CheckInDocument(byte[] content)
{
ValidationResultInfo retValue = null;
if (CheckOutContext.Current != null && CheckOutContext.Current.Status != null)
{
CheckOutStatus checkOutStatus = CheckOutContext.Current.Status;
string checkInComments = CheckOutContext.Current.CheckInComments;
retValue = _webServices.CheckInDocument(checkOutStatus, GetInfoUtente(), content, checkInComments);
if (retValue.Value)
{
CheckOutContext.Current = null;
if (System.Web.HttpContext.Current.Session["schedaAllegatoSelezionato"] != null)
{
System.Web.HttpContext.Current.Session["schedaAllegatoSelezionato"] = null;
}
}
}
else
{
retValue = new ValidationResultInfo();
}
return(retValue);
}
public void OperationError_IEquatable()
{
ValidationResultInfo error1 = new ValidationResultInfo("message", 10, "stacktrace", new string[] { "foo" });
ValidationResultInfo error2 = new ValidationResultInfo("message", 10, "stacktrace", new string[] { "foo" });
ValidationResultInfo error3 = new ValidationResultInfo("message2", 10, "stacktrace", new string[] { "foo" });
ValidationResultInfo error4 = new ValidationResultInfo("message2", 2, null, new string[] { "foo" });
// compare same object ref
Assert.IsTrue(((IEquatable <ValidationResultInfo>)error1).Equals(error1));
// compare different object ref but same data fields
Assert.IsTrue(((IEquatable <ValidationResultInfo>)error1).Equals(error2));
// compare objects with 1 different field
Assert.IsFalse(((IEquatable <ValidationResultInfo>)error1).Equals(error3));
// compare objects with all different fields
Assert.IsFalse(((IEquatable <ValidationResultInfo>)error1).Equals(error4));
// verify List.Contains uses our implementation of IEquatable.Equals
List <ValidationResultInfo> errors = new List <ValidationResultInfo>()
{
error1, error3, error4
};
Assert.IsTrue(errors.Contains(error2));
}
/// <summary>
/// CheckOut di un documento senza estrarre il contenuto del file
/// </summary>
/// <param name="documentLocation"></param>
/// <param name="machineName"></param>
/// <param name="checkOutStatus"></param>
/// <returns></returns>
public static ValidationResultInfo CheckOutDocument(string documentLocation, string machineName, out CheckOutStatus checkOutStatus)
{
ValidationResultInfo retValue = null;
checkOutStatus = null;
SchedaDocumento schedaDocumento = CheckInOutServices.CurrentSchedaDocumento;
if (schedaDocumento != null)
{
string docnum = schedaDocumento.docNumber;
string docid = schedaDocumento.systemId;
if (IsSelectedTabAllegati())
{
docnum = UIManager.DocumentManager.GetSelectedAttachment().docNumber;
docid = UIManager.DocumentManager.GetSelectedAttachment().docNumber;
}
retValue = _webServices.CheckOutDocument(docid, docnum, documentLocation, machineName, GetInfoUtente(), out checkOutStatus);
if (retValue.Value && !IsSelectedTabAllegati())
{
schedaDocumento.checkOutStatus = checkOutStatus;
CheckOutAppletContext.Current = new CheckOutAppletContext(schedaDocumento);
}
}
return(retValue);
}
/// <summary>
/// CheckIn di un documento
/// </summary>
/// <param name="content"></param>
/// <returns></returns>
public static ValidationResultInfo CheckInDocument(byte[] content)
{
ValidationResultInfo retValue = null;
if (CheckOutContext.Current != null && CheckOutContext.Current.Status != null)
{
CheckOutStatus checkOutStatus = CheckOutContext.Current.Status;
string checkInComments = CheckOutContext.Current.CheckInComments;
retValue = _webServices.CheckInDocument(checkOutStatus, GetInfoUtente(), content, checkInComments);
if (retValue.Value)
{
CheckOutContext.Current = null;
SiteNavigation.CallContext context = SiteNavigation.CallContextStack.CurrentContext;
if (context.ContextState["schedaAllegatoSelezionato"] != null)
{
context.ContextState.Remove("schedaAllegatoSelezionato");
}
}
}
else
{
retValue = new ValidationResultInfo();
}
return(retValue);
}
public static ValidationResultInfo Validate(this object obj)
{
var validationResultInfo = new ValidationResultInfo();
var context = new ValidationContext(obj, null, null);
var validationResults = new Dictionary <string, List <ValidationResult> >();
foreach (var prop in obj.GetType().GetProperties())
{
var attrs = prop
.GetCustomAttributes(false)
.OfType <ValidationAttribute>()
.ToArray();
if (attrs.Count() > 0)
{
var results = new List <ValidationResult>();
var displayAttribute = prop.GetCustomAttribute <DisplayAttribute>();
if (displayAttribute != null)
{
context.DisplayName = displayAttribute.Name;
}
if (!Validator.TryValidateValue(prop.GetValue(obj), context, results, attrs))
{
validationResults.Add(prop.Name, results);
}
}
}
validationResultInfo.ValidationResults = validationResults;
return(validationResultInfo);
}
public void OperationError_Sanity()
{
// test default ctor
ValidationResultInfo error = new ValidationResultInfo();
Assert.IsNull(error.Message);
Assert.AreEqual <int>(0, error.ErrorCode);
Assert.IsNull(error.StackTrace);
// test ctor with message/member argument
error = new ValidationResultInfo("my error message", new string[] { "foo" });
Assert.AreEqual("my error message", error.Message);
Assert.AreEqual <int>(0, error.ErrorCode);
Assert.IsNull(error.StackTrace);
Assert.AreEqual(1, error.SourceMemberNames.Count());
Assert.IsTrue(error.SourceMemberNames.Contains("foo"));
// test ctor with all arguments
error = new ValidationResultInfo("message", 10, "stacktrace", new string[] { "foo" });
Assert.AreEqual("message", error.Message);
Assert.AreEqual(10, error.ErrorCode);
Assert.AreEqual("stacktrace", error.StackTrace);
Assert.AreEqual(1, error.SourceMemberNames.Count());
Assert.IsTrue(error.SourceMemberNames.Contains("foo"));
}
/// <summary>
/// Checkout di un documento e download del contenuto del file
/// </summary>
/// <param name="idDocument"></param>
/// <param name="documentNumber"></param>
/// <param name="machineName"></param>
/// <param name="documentLocation">Percorso di estrazione del file</param>
/// <param name="downloadFile">Se true, viene effettuato il download del file contestualmente al checkout</param>
private void CheckOutDocument(string idDocument, string documentNumber, string documentLocation, string machineName, bool downloadFile)
{
CheckOutStatus checkOutStatus;
ValidationResultInfo result = null;
if (downloadFile)
{
byte[] content;
result = CheckInOutServices.CheckOutDocumentWithFile(documentLocation, machineName, out checkOutStatus, out content);
if (result.Value)
{
SessionContent = content;
}
}
else
{
result = CheckInOutServices.CheckOutDocument(documentLocation, machineName, out checkOutStatus);
}
if (!result.Value)
{
// Scrittura dei messaggi di errore nel checkout
Response.Write(this.GetErrorMessage(result));
}
}
/// Verifica presenza dati obbligatori della qualifica
private static ValidationResultInfo IsValidRequiredFieldsQualifica(
DBActionTypeRegistroEnum actionType,
DocsPaVO.Qualifica.Qualifica qual)
{
ValidationResultInfo retValue = new ValidationResultInfo();
BrokenRule brokenRule = null;
if (actionType == DBActionTypeRegistroEnum.InsertMode ||
actionType == DBActionTypeRegistroEnum.UpdateMode)
{
if (qual.CODICE == null || qual.CODICE == string.Empty)
{
retValue.Value = false;
brokenRule = new BrokenRule();
brokenRule.ID = "CODICE_QUALIFICA";
brokenRule.Description = "Codice qualifica mancante";
retValue.BrokenRules.Add(brokenRule);
}
if (qual.DESCRIZIONE == null || qual.DESCRIZIONE == string.Empty)
{
retValue.Value = false;
brokenRule = new BrokenRule();
brokenRule.ID = "DESCRIZIONE_QUALIFICA";
brokenRule.Description = "Descrizione qualifica mancante";
retValue.BrokenRules.Add(brokenRule);
}
}
retValue.Value = (retValue.BrokenRules.Count == 0);
return(retValue);
}
private void MoveDocument(string docsId, string oldParentId, string parentId)
{
try {
string messaggio = string.Empty;
string[] docId = new string[1] {
docsId
};
if (docsId.IndexOf(",") > 0)
{
docId = docsId.Split(',');
}
InfoUtente infoUtente = UserManager.GetInfoUser();
DocsPaWR.Folder fromFolder = ProjectManager.getFolder(this, oldParentId);
fromFolder = ProjectManager.getFolder(this, fromFolder);
DocsPaWR.Folder toFolder = ProjectManager.getFolder(this, parentId);
toFolder = ProjectManager.getFolder(this, toFolder);
foreach (string docNumber in docId)
{
string idProfile = docNumber.Replace("doc", "");
SchedaDocumento doc = DocumentManager.getDocumentDetails(this, idProfile, idProfile);
if (doc.protocollo != null && doc.protocollo.protocolloAnnullato != null)
{
// alert documento annullato
this.html_data.Text += "<" + "script type=\"text/javascript\">ajaxDialogModal('AlertProjectMoveDocNoAllowedProtCanceled', 'warning', '');<" + "/script>\n";
}
//else if (Convert.ToInt32(doc.accessRights) < Convert.ToInt32(HMdiritti.HMdiritti_Write))
//{
// // alert no diritti in scrittura
// this.html_data.Text += "<" + "script type=\"text/javascript\">ajaxDialogModal('AlertProjectMoveDocNoAllowedNoWrite', 'warning', '');<" + "/script>\n";
//}
else
{
// add new
UIManager.AddDocInProjectManager.addDocumentoInFolder(idProfile, toFolder.systemID, infoUtente);
// delete old
ValidationResultInfo risultato = UIManager.ProjectManager.deleteDocFromFolder(fromFolder, infoUtente, idProfile, RapidClassificationRequired.ToString(), out messaggio);
if (risultato != null && risultato.BrokenRules.Length > 0)
{
this.html_data.Text += "<" + "script type=\"text/javascript\">ajaxDialogModal('AlertProjectRemoveDoc', 'error', '');<" + "/script>\n";
}
else
if (!string.IsNullOrEmpty(messaggio))
{
this.html_data.Text += "<" + "script type=\"text/javascript\">ajaxDialogModal('ErrorProjectRemoveDoc', 'error', '');<" + "/script>\n";
}
}
}
}
catch (System.Exception ex)
{
UIManager.AdministrationManager.DiagnosticError(ex);
return;
}
}
/// <summary>
/// Initializes a new <see cref="OperationException"/> instance.
/// </summary>
/// <param name="message">A message describing the exception.</param>
/// <param name="operationError">The <see cref="ValidationResultInfo"/> associated with this exception.</param>
/// <exception cref="ArgumentNullException">if <paramref name="operationError"/> is null.</exception>
internal OperationException(string message, ValidationResultInfo operationError)
: this(message, new[] { operationError })
{
if (operationError == null)
{
throw new ArgumentNullException("operationError");
}
}
/// Cancellazione peopleGroups
public static ValidationResultInfo DeletePeopleGroups(String idPeopleGroups)
{
ValidationResultInfo retValue = new ValidationResultInfo();
DocsPaDB.Query_DocsPAWS.Utenti dbUtenti = new DocsPaDB.Query_DocsPAWS.Utenti();
dbUtenti.DeletePeopleGroups(idPeopleGroups);
return(retValue);
}
/// <summary>
/// Initializes a new <see cref="OperationException"/> instance.
/// </summary>
/// <param name="message">A message describing the exception.</param>
/// <param name="operationError">The <see cref="ValidationResultInfo"/> associated with this exception.</param>
/// <exception cref="ArgumentNullException">if <paramref name="operationError"/> is null.</exception>
internal OperationException(string message, ValidationResultInfo operationError)
: this(message, new[] { operationError })
{
if (operationError == null)
{
throw new ArgumentNullException("operationError");
}
}
/// <summary>
/// Metodo per la formattazione degli errori di validazione
/// </summary>
/// <param name="validationResultInfo">Errori di validazione da visualizzare</param>
private void FormatValidationError(ValidationResultInfo validationResultInfo)
{
StringBuilder plainMessages = new StringBuilder("Sono stati rilevati i seguenti errori di validazione:\\n");
validationResultInfo.BrokenRules.Select(rule => { plainMessages.AppendFormat("{0}\\n\\n", rule.Description); return(rule); }).ToList();
this.AjaxMessageBox.ShowMessage(plainMessages.ToString());
}
/// Cancellazione qualifica
public static ValidationResultInfo DeleteQual(String idQualifica, int idAmministrazione)
{
ValidationResultInfo retValue = new ValidationResultInfo();
DocsPaDB.Query_DocsPAWS.Utenti dbUtenti = new DocsPaDB.Query_DocsPAWS.Utenti();
dbUtenti.DeleteQual(idQualifica, idAmministrazione.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();
retValue.Value = false;
retValue.BrokenRules.Add(new BrokenRule("CHANGE_PWD_NOT_SUPPORTED", "Cambio password non supportato dal documentale CDC", BrokenRule.BrokenRuleLevelEnum.Error));
return(retValue);
}
/// <summary>
/// Cancellazione di un tipo funzione
/// </summary>
/// <param name="tipoFunzione"></param>
/// <returns></returns>
public static ValidationResultInfo DeleteTipoFunzione(OrgTipoFunzione tipoFunzione)
{
ValidationResultInfo retValue = CanDeleteTipoFunzione(tipoFunzione);
if (retValue.Value)
{
DBProvider dbProvider = new DBProvider();
try
{
// Cancellazione tipo funzione
DocsPaUtils.Query queryDef = DocsPaUtils.InitQuery.getInstance().getQuery("AMM_D_DELETE_TIPO_FUNZIONE");
queryDef.setParam("systemID", tipoFunzione.IDTipoFunzione);
string commandText = queryDef.getSQL();
logger.Debug(commandText);
int rowsAffected = 0;
retValue.Value = dbProvider.ExecuteNonQuery(commandText, out rowsAffected);
retValue.Value = (retValue.Value && rowsAffected == 1);
if (retValue.Value)
{
// Cancellazione funzioni elementari
queryDef = DocsPaUtils.InitQuery.getInstance().getQuery("AMM_D_DELETE_FUNZIONI_TIPO_FUNZIONE");
queryDef.setParam("idTipoFunzione", tipoFunzione.IDTipoFunzione);
commandText = queryDef.getSQL();
logger.Debug(commandText);
retValue.Value = dbProvider.ExecuteNonQuery(commandText);
}
if (retValue.Value)
{
dbProvider.CommitTransaction();
}
else
{
dbProvider.RollbackTransaction();
}
}
catch
{
dbProvider.RollbackTransaction();
retValue.Value = false;
}
finally
{
dbProvider.Dispose();
dbProvider = null;
}
}
return(retValue);
}
public static DocsPaVO.Validations.ValidationResultInfo UpdateMezzoSpedizione(MezzoSpedizione m_sped)
{
DocsPaVO.Validations.ValidationResultInfo retValue = new ValidationResultInfo();
DocsPaDB.Query_DocsPAWS.Amministrazione dbAmm = new DocsPaDB.Query_DocsPAWS.Amministrazione();
retValue.Value = dbAmm.UpdateMezzoSpedizione(m_sped);
return(retValue);
}
/// <summary>
/// Annullamento del blocco sul documento
/// </summary>
private void UndoCheckOutDocument()
{
ValidationResultInfo retValue = CheckInOutServices.UndoCheckOutDocument();
if (!retValue.Value)
{
// Scrittura dei messaggi di errore nel checkout
Response.Write(this.GetErrorMessage(retValue));
}
}
public void User_withValid_validations_shouldPass()
{
//arrange
var u = new Fixture();
User user = u.Create<User>();
//act
ValidationResultInfo r = user.Validate();
//assert
Assert.That(r.IsValid, Is.True, "Validation should pass");
}
/// <summary>
/// Aggiornamento di un tipo chiave
/// </summary>
/// <param name="tipoFunzione"></param>
/// <returns></returns>
public static ValidationResultInfo UpdateChiaveConfigurazione(ChiaveConfigurazione chiaveConfig)
{
ValidationResultInfo retValue = CanUpdateChiaveConfig(chiaveConfig);
if (retValue.Value)
{
IDatabase database = DatabaseFactory.CreateDatabase();
try
{
//database.BeginTransaction(); //non c'è bisogno della transazione perchè viene aggiornata una sola tabella
// Aggiornamento tipo chiave
DocsPaUtils.Query queryDef = DocsPaUtils.InitQuery.getInstance().getQuery("AMM_U_UPDATE_CHIAVE_CONFIGURAZIONE");
queryDef.setParam("descrizione", GetStringParameterValue(chiaveConfig.Descrizione));
queryDef.setParam("valore", GetStringParameterValue(chiaveConfig.Valore));
queryDef.setParam("systemID", chiaveConfig.IDChiave);
string commandText = queryDef.getSQL();
logger.Debug(commandText);
int rowsAffected = 0;
retValue.Value = database.ExecuteNonQuery(commandText, out rowsAffected);
if (retValue.Value)
{
retValue.Value = (retValue.Value && rowsAffected == 1);
}
if (!retValue.Value)
{
retValue.BrokenRules.Add(new BrokenRule("AGGIORNAMENTO_CHIAVE_CONFIGURAZIONE", "Non è stata aggiornata alcuna chiave"));
}
//if (retValue.Value)
// database.CommitTransaction();
//else
// database.RollbackTransaction();
}
catch
{
//database.RollbackTransaction();
retValue.Value = false;
}
finally
{
database.Dispose();
database = null;
}
}
return(retValue);
}
public void PollingCentre_withValid_validations_shouldPass()
{
//arrange
var u = new Fixture();
PollingCentre pollingCentre = u.Create <PollingCentre>();
//act
ValidationResultInfo r = pollingCentre.Validate();
//assert
Assert.That(r.IsValid, Is.True, "Validation should pass");
}
public void Settings_withValid_validations_shouldPass()
{
//arrange
var u = new Fixture();
Settings settings = u.Create <Settings>();
//act
ValidationResultInfo r = settings.Validate();
//assert
Assert.That(r.IsValid, Is.True, "Validation should pass");
}
public void PoliticalParty_withValid_validations_shouldPass()
{
//arrange
var u = new Fixture();
PoliticalParty politicalParty = u.Create <PoliticalParty>();
//act
ValidationResultInfo r = politicalParty.Validate();
//assert
Assert.That(r.IsValid, Is.True, "Validation should pass");
}
public void Region_withValid_validations_shouldPass()
{
//arrange
var u = new Fixture();
Region region = u.Create <Region>();
//act
ValidationResultInfo r = region.Validate();
//assert
Assert.That(r.IsValid, Is.True, "Validation should pass");
}
public void Constructor_SetState()
{
ValidationResultInfo error = new ValidationResultInfo();
ValidationResultInfo[] errors = new[] { error };
OperationException exception;
exception = new OperationException("message", error);
Assert.AreEqual("message", exception.Message);
Assert.AreEqual(1, exception.OperationErrors.Count());
Assert.AreSame(error, exception.OperationErrors.Single());
exception = new OperationException("message", errors);
Assert.AreEqual("message", exception.Message);
Assert.AreEqual(1, exception.OperationErrors.Count());
Assert.AreSame(error, exception.OperationErrors.Single());
}
public void OperationError_IEquatable()
{
ValidationResultInfo error1 = new ValidationResultInfo("message", 10, "stacktrace", new string[] { "foo" });
ValidationResultInfo error2 = new ValidationResultInfo("message", 10, "stacktrace", new string[] { "foo" });
ValidationResultInfo error3 = new ValidationResultInfo("message2", 10, "stacktrace", new string[] { "foo" });
ValidationResultInfo error4 = new ValidationResultInfo("message2", 2, null, new string[] { "foo" });
// compare same object ref
Assert.IsTrue(((IEquatable<ValidationResultInfo>)error1).Equals(error1));
// compare different object ref but same data fields
Assert.IsTrue(((IEquatable<ValidationResultInfo>)error1).Equals(error2));
// compare objects with 1 different field
Assert.IsFalse(((IEquatable<ValidationResultInfo>)error1).Equals(error3));
// compare objects with all different fields
Assert.IsFalse(((IEquatable<ValidationResultInfo>)error1).Equals(error4));
// verify List.Contains uses our implementation of IEquatable.Equals
List<ValidationResultInfo> errors = new List<ValidationResultInfo>() { error1, error3, error4 };
Assert.IsTrue(errors.Contains(error2));
}
public void OperationError_Sanity()
{
// test default ctor
ValidationResultInfo error = new ValidationResultInfo();
Assert.IsNull(error.Message);
Assert.AreEqual<int>(0, error.ErrorCode);
Assert.IsNull(error.StackTrace);
// test ctor with message/member argument
error = new ValidationResultInfo("my error message", new string[] { "foo" });
Assert.AreEqual("my error message", error.Message);
Assert.AreEqual<int>(0, error.ErrorCode);
Assert.IsNull(error.StackTrace);
Assert.AreEqual(1, error.SourceMemberNames.Count());
Assert.IsTrue(error.SourceMemberNames.Contains("foo"));
// test ctor with all arguments
error = new ValidationResultInfo("message", 10, "stacktrace", new string[] { "foo" });
Assert.AreEqual("message", error.Message);
Assert.AreEqual(10, error.ErrorCode);
Assert.AreEqual("stacktrace", error.StackTrace);
Assert.AreEqual(1, error.SourceMemberNames.Count());
Assert.IsTrue(error.SourceMemberNames.Contains("foo"));
}
private static string GetErrorMessageForValidation(ValidationResultInfo validationResultInfo)
{
return validationResultInfo.ToString();
}
private void InvokeAction(HttpActionDescriptor action, object[] parameters, ChangeSetEntry changeSetEntry)
{
try
{
Collection<HttpParameterDescriptor> pds = action.GetParameters();
Dictionary<string, object> paramMap = new Dictionary<string, object>(pds.Count);
for (int i = 0; i < pds.Count; i++)
{
paramMap.Add(pds[i].ParameterName, parameters[i]);
}
// TODO this method is not correctly observing the execution results, the catch block below is wrong. 385801
action.ExecuteAsync(ActionContext.ControllerContext, paramMap);
}
catch (TargetInvocationException tie)
{
ValidationException vex = tie.GetBaseException() as ValidationException;
if (vex != null)
{
ValidationResultInfo error = new ValidationResultInfo(vex.Message, 0, String.Empty, vex.ValidationResult.MemberNames);
if (changeSetEntry.ValidationErrors != null)
{
changeSetEntry.ValidationErrors = changeSetEntry.ValidationErrors.Concat(new ValidationResultInfo[] { error }).ToArray();
}
else
{
changeSetEntry.ValidationErrors = new ValidationResultInfo[] { error };
}
}
else
{
throw;
}
}
}
private void InvokeAction(HttpActionDescriptor action, object[] parameters, ChangeSetEntry changeSetEntry)
{
try
{
Collection<HttpParameterDescriptor> pds = action.GetParameters();
Dictionary<string, object> paramMap = new Dictionary<string, object>(pds.Count);
for (int i = 0; i < pds.Count; i++)
{
paramMap.Add(pds[i].ParameterName, parameters[i]);
}
// TODO - Issue #103
// This method is not correctly observing the execution results, the catch block below is wrong.
// Submit should be Task<bool>, not bool, and should model bind for the CancellationToken which would then
// be propagated through to all the helper methods (one or more of which might also need to be made async,
// once we start respecting the fact that the read/write actions should be allowed to be async).
action.ExecuteAsync(ActionContext.ControllerContext, paramMap, CancellationToken.None);
}
catch (TargetInvocationException tie)
{
ValidationException vex = tie.GetBaseException() as ValidationException;
if (vex != null)
{
ValidationResultInfo error = new ValidationResultInfo(vex.Message, 0, String.Empty, vex.ValidationResult.MemberNames);
if (changeSetEntry.ValidationErrors != null)
{
changeSetEntry.ValidationErrors = changeSetEntry.ValidationErrors.Concat(new ValidationResultInfo[] { error }).ToArray();
}
else
{
changeSetEntry.ValidationErrors = new ValidationResultInfo[] { error };
}
}
else
{
throw;
}
}
}
/// <summary>
/// This method invokes the user overridable <see cref="PersistChangeSet"/> method wrapping the call
/// with the appropriate exception handling logic. All framework calls to <see cref="PersistChangeSet"/>
/// must go through this method. Some data sources have their own validation hook points,
/// so if a <see cref="ValidationException"/> is thrown at that level, we want to capture it.
/// </summary>
/// <returns>True if the <see cref="ChangeSet"/> was persisted successfully, false otherwise.</returns>
private bool PersistChangeSetInternal()
{
try
{
PersistChangeSet();
}
catch (ValidationException e)
{
// if a validation exception is thrown for one of the entities in the changeset
// set the error on the corresponding ChangeSetEntry
if (e.Value != null && e.ValidationResult != null)
{
IEnumerable<ChangeSetEntry> updateOperations =
ChangeSet.ChangeSetEntries.Where(
p => p.Operation == ChangeOperation.Insert ||
p.Operation == ChangeOperation.Update ||
p.Operation == ChangeOperation.Delete);
ChangeSetEntry operation = updateOperations.SingleOrDefault(p => Object.ReferenceEquals(p.Entity, e.Value));
if (operation != null)
{
ValidationResultInfo error = new ValidationResultInfo(e.ValidationResult.ErrorMessage, e.ValidationResult.MemberNames);
error.StackTrace = e.StackTrace;
operation.ValidationErrors = new List<ValidationResultInfo>() { error };
}
}
else
{
throw;
}
}
return !ChangeSet.HasError;
}
