public ActionResult AddItem(ItemValidation item)
{
Item obj = new Item();
obj.Barcode = item.Barcode;
obj.Name = item.Name;
obj.Description = item.Description;
obj.Shelf = item.Shelf;
obj.PurchasePrice = item.PurchasePrice;
obj.SalePrice = item.SalePrice;
obj.PiecesPerPack = item.PiecesPerPack;
obj.SalePricePerPiece = item.SalePricePerPiece;
obj.OtherBonus = item.OtherBonus;
obj.ManufacturerID = item.ManufacturerID;
obj.ItemTypeID = item.ItemTypeID;
obj.PurchasePercentage = item.PurchasePercentage;
obj.SalePercentage = item.SalePercentage;
obj.TotalStock = 0;
obj.LooseQuantitySold = 0;
obj.PiecesPerPack = item.PiecesPerPack;
context.Items.Add(obj);
context.SaveChanges();
ModelState.Clear();
return(View());
}
/// <summary>
/// Validates the property.
/// </summary>
/// <param name="validation">The validation.</param>
/// <param name="itemResult">The item result.</param>
/// <returns><c>true</c> if the validation is successful, <c>false</c> otherwise.</returns>
private bool ValidateProperty(ItemValidation validation, ValidationItemResult itemResult)
{
IPropertyData propertyData;
if (!this.ElementLocator.TryGetProperty(validation.FieldName, out propertyData))
{
if (validation.Comparer is DoesNotExistComparer)
{
itemResult.NoteValidationResult(validation, successful: true, actualValue: null);
return(true);
}
itemResult.NoteMissingProperty(validation);
return(false);
}
string actualValue = null;
bool? successful = null;
this.DoValidate <IPropertyData>(propertyData, e =>
{
successful = e.ValidateItem(validation, out actualValue);
return(successful.Value);
});
itemResult.NoteValidationResult(validation, successful.Value, actualValue);
return(successful.Value);
}
/// <summary>
/// Initializes a new instance of the <see cref="PropertyResult" /> class.
/// </summary>
/// <param name="itemValidation">The item validation.</param>
/// <param name="successful">if set to <c>true</c> [successful].</param>
/// <param name="actualValue">The actual value.</param>
internal PropertyResult(ItemValidation itemValidation, bool successful, string actualValue)
{
this.FieldExists = true;
this.Validation = itemValidation;
this.IsValid = successful;
this.ActualValue = actualValue;
}
/// <summary>
/// Processes the specified validation.
/// </summary>
/// <param name="validation">The validation.</param>
/// <param name="comparer">The optional comparer, uses equals by default.</param>
/// <returns>The configured validation, same object reference.</returns>
public static ItemValidation Process(this ItemValidation validation, IValidationComparer comparer = null)
{
validation.FieldName = validation.RawFieldName;
validation.ComparisonValue = validation.RawComparisonValue;
validation.Comparer = comparer ?? new EqualsComparer();
return(validation);
}
public void TestToStringWithNullValueReturnsRelevantItemData()
{
var item = new ItemValidation(" Field ", " equals ", null);
var result = item.ToString();
Assert.AreEqual("Field equals <NULL>", result);
}
public void TestConstructorRawValuesWhenValuesHaveWhitespaceAreTrimmedWhenStored()
{
var item = new ItemValidation(" Field ", " equals ", " value ");
Assert.AreEqual("Field", item.RawFieldName);
Assert.AreEqual("equals", item.RawComparisonType);
Assert.AreEqual("value", item.RawComparisonValue);
}
public void TestToStringReturnsRelevantItemData()
{
var item = new ItemValidation(" Field ", " equals ", " value ");
var result = item.ToString();
Assert.AreEqual("Field equals value", result);
}
/// <summary>
/// Validates the token.
/// </summary>
/// <param name="validation">The validation.</param>
/// <param name="itemResult">The validation item result.</param>
/// <returns><c>true</c> if the validation is successful, <c>false</c> otherwise.</returns>
private bool ValidateToken(ItemValidation validation, ValidationItemResult itemResult)
{
var tokenValue = this.tokenManager.GetTokenByKey(validation.FieldName);
var successful = validation.Compare(null, tokenValue);
itemResult.NoteValidationResult(validation, successful, tokenValue);
return(successful);
}
/// <summary>
/// Validates the item or property matches the expected expression.
/// </summary>
/// <param name="validation">The validation item.</param>
/// <param name="actualValue">The actual value if validation fails.</param>
/// <returns>
/// <c>true</c> if the items are valid; otherwise <c>false</c>.
/// </returns>
public override bool ValidateItem(ItemValidation validation, out string actualValue)
{
string realValue = null;
var result = this.action(this.ElementHandler, o => this.ComparePropertyValue(o, validation, out realValue));
actualValue = realValue;
return(result);
}
public void TestConstructorRawValuesWhenNullSetsNulls()
{
var item = new ItemValidation(null, null, null);
Assert.IsNull(item.RawFieldName);
Assert.IsNull(item.RawComparisonType);
Assert.IsNull(item.RawComparisonValue);
Assert.IsNull(item.FieldName);
Assert.IsNull(item.ComparisonValue);
}
public void TestConstructorRawValuesWhenValuesAreSetAreStored()
{
var item = new ItemValidation("Field", "equals", "value");
Assert.AreEqual("Field", item.RawFieldName);
Assert.AreEqual("equals", item.RawComparisonType);
Assert.AreEqual("value", item.RawComparisonValue);
Assert.IsNull(item.FieldName);
Assert.IsNull(item.ComparisonValue);
}
/// <summary>
/// Compares the property value.
/// </summary>
/// <param name="propertyValue">The property value.</param>
/// <param name="validation">The validation.</param>
/// <param name="actualValue">The actual value.</param>
/// <returns>
/// <c>true</c> if the comparison is valid.
/// </returns>
protected bool ComparePropertyValue(object propertyValue, ItemValidation validation, out string actualValue)
{
var stringItems = propertyValue as IEnumerable <string>;
if (stringItems != null)
{
var list = stringItems.ToList();
actualValue = string.Join(",", list);
return(list.Any(s => validation.Compare(this, s)));
}
actualValue = propertyValue != null?propertyValue.ToString() : null;
return(validation.Compare(this, actualValue));
}
/// <summary>
/// Validates the property.
/// </summary>
/// <param name="validation">The validation.</param>
/// <param name="itemResult">The item result.</param>
/// <returns><c>true</c> if the validation is successful, <c>false</c> otherwise.</returns>
private bool ValidateProperty(ItemValidation validation, ValidationItemResult itemResult)
{
IPropertyData propertyData;
if (!this.ElementLocator.TryGetProperty(validation.FieldName, out propertyData))
{
itemResult.NoteMissingProperty(validation);
return(false);
}
string actualValue;
var successful = propertyData.ValidateItem(validation, out actualValue);
itemResult.NoteValidationResult(validation, successful, actualValue);
return(successful);
}
public void TestCompareWithNullComparerReturnsFalse()
{
var item = new ItemValidation(" Field ", " equals ", " value ")
{
FieldName = "field",
ComparisonValue = "value",
Comparer = null
};
var propertyData = new Mock <IPropertyData>(MockBehavior.Strict);
var result = item.Compare(propertyData.Object, "value");
Assert.AreEqual(false, result);
propertyData.VerifyAll();
}
private Dictionary <bool, List <string> > ValidateForm()
{
Dictionary <string, string> itemFields = new Dictionary <string, string>();
itemFields.Add("itemItem", selectItemComboBox.Text);
itemFields.Add("itemAsset", editItemAssetText.Text);
itemFields.Add("itemArrived", editItemArrivedText.Text);
itemFields.Add("itemInvoice", editItemInvoiceText.Text);
itemFields.Add("itemCCD", editItemCcdText.Text);
itemFields.Add("itemPosition", editItemPositionCcdText.Text);
itemFields.Add("itemStatus", editItemStatusText.Text);
itemFields.Add("itemContainer", editItemContainerText.Text);
var output = ItemValidation.ValidateItem(itemFields);
return(output);
}
/// <summary>
/// Gets the element text.
/// </summary>
/// <param name="validation">The validation.</param>
/// <param name="element">The element.</param>
/// <returns>The cleaned text from the element.</returns>
protected string GetElementText(ItemValidation validation, TElement element)
{
if (!validation.RequiresFieldValue)
{
return(null);
}
var text = this.elementHandler.GetElementText(element);
// Trim whitespace from text since the tables in SpecFlow will anyway.
if (text != null)
{
text = text.Trim();
text = text.Replace(Environment.NewLine, " ");
}
return(text);
}
/// <summary>
/// Validates the item or property matches the expected expression.
/// </summary>
/// <param name="validation">The validation item.</param>
/// <param name="actualValue">The actual value if validation fails.</param>
/// <returns>
/// <c>true</c> if the items are valid; otherwise <c>false</c>.
/// </returns>
public override bool ValidateItem(ItemValidation validation, out string actualValue)
{
string realValue = null;
var compareWrapper = new Func <TControl, bool>(
e =>
{
var text = this.GetControlText(validation, e);
realValue = text;
return(validation.Compare(this, text));
});
if (validation.CheckControlExistence)
{
this.ThrowIfControlDoesNotExist();
}
var result = this.controlAction(this.ControlHandler, compareWrapper);
actualValue = realValue;
return(result);
}
/// <summary>
/// Validates the item or property matches the expected expression.
/// </summary>
/// <param name="validation">The validation item.</param>
/// <param name="actualValue">The actual value if validation fails.</param>
/// <returns>
/// <c>true</c> if the items are valid; otherwise <c>false</c>.
/// </returns>
public override bool ValidateItem(ItemValidation validation, out string actualValue)
{
string realValue = null;
var compareWrapper = new Func <TElement, bool>(
e =>
{
var text = this.GetElementText(validation, e);
realValue = text;
return(validation.Compare(this, text));
});
if (validation.CheckElementExistence)
{
this.ThrowIfElementDoesNotExist();
}
var result = this.elementAction(this.ElementHandler, compareWrapper);
actualValue = realValue;
return(result);
}
/// <summary>
/// Validates the item or property matches the expected expression.
/// </summary>
/// <param name="validation">The validation item.</param>
/// <param name="actualValue">The actual value if validation fails.</param>
/// <returns>
/// <c>true</c> if the items are valid; otherwise <c>false</c>.
/// </returns>
public override bool ValidateItem(ItemValidation validation, out string actualValue)
{
string realValue = null;
var compareWrapper = new Func <TElement, bool>(
e =>
{
var text = this.GetElementText(validation, e);
realValue = text;
return(validation.Compare(this, text));
});
var result = this.action(
this.ElementHandler,
o =>
{
var list = (IElementList <TElement, TElement>)o;
return(compareWrapper(list.Parent));
});
actualValue = realValue;
return(result);
}
/// <summary>
/// Notes the missing property.
/// </summary>
/// <param name="itemValidation">The item validation.</param>
internal void NoteMissingProperty(ItemValidation itemValidation)
{
this.PropertyResults.Add(new PropertyResult(itemValidation));
}
/// <summary> /// Validates the item or property matches the expected expression. /// </summary> /// <param name="validation">The validation item.</param> /// <param name="actualValue">The actual value if validation fails.</param> /// <returns> /// <c>true</c> if the items are valid; otherwise <c>false</c>. /// </returns> public abstract bool ValidateItem(ItemValidation validation, out string actualValue);
/// <summary>
/// Notes the validation result.
/// </summary>
/// <param name="itemValidation">The item validation.</param>
/// <param name="successful">if set to <c>true</c> the validation was successful.</param>
/// <param name="actualValue">The actual value.</param>
internal void NoteValidationResult(ItemValidation itemValidation, bool successful, string actualValue)
{
this.PropertyResults.Add(new PropertyResult(itemValidation, successful, actualValue));
}
/// <summary>
/// Initializes a new instance of the <see cref="PropertyResult"/> class.
/// </summary>
/// <param name="validation">The validation.</param>
internal PropertyResult(ItemValidation validation)
{
this.Validation = validation;
this.IsValid = false;
this.FieldExists = false;
}
public override bool ValidateItem(ItemValidation validation, out string actualValue)
{
throw new NotImplementedException();
}
public ItemsController(IItemBusinessLogic itemBusinessLogic, ItemValidation itemValidation)
{
this.itemBusinessLogic = itemBusinessLogic;
this.itemValidation = itemValidation;
}
/// <summary>
/// Validates the item.
/// </summary>
/// <param name="validation">The validation.</param>
/// <param name="actualValue">The actual value.</param>
/// <returns><c>true</c> if the validation is successful, <c>false</c> otherwise.</returns>
public override bool ValidateItem(ItemValidation validation, out string actualValue)
{
actualValue = this.GetCurrentValue();
return(validation.Compare(this, actualValue));
}
