public void MultipleDishesMorningRuleIsFalse()
{
IOrder order = new Order();
order.SetTimeOfDay(Enums.TimeOfDay.Morning);
Assert.IsFalse(OrderValidation.ValidateMultipleDishes(order, Enums.DishTypes.Entree));
}
/// <summary>
/// Process the order dishes typed in the input string.
/// </summary>
/// <param name="order">The order which will receive the processed data.</param>
public static void ProcessOrder(IOrder order)
{
// Creates input list
var inputList = Helpers.CreateInputList(order.InputString);
if (inputList == null)
{
// If inputList is null, sets the order's error property
order.SetError();
return;
}
// Updates order's time of day
if (!OrderValidation.ValidateTimeOfDay(order, inputList[0]))
{
return;
}
// Fill dishes based on order's time of day
order.SetDishes();
// Input list dishes processing
for (int i = 1; i < inputList.Count; i++)
{
// If dish processing has an error, then break the processing
if (!Dishes.ProcessDishes(order, inputList[i]))
{
break;
}
}
}
public void MultipleDishesNightRuleIsFalse()
{
IOrder order = new Order();
order.SetTimeOfDay(Enums.TimeOfDay.Night);
Assert.IsFalse(OrderValidation.ValidateMultipleDishes(order, Enums.DishTypes.Dessert));
}
public OrderResponse Post([FromBody] OrderRequest orderRequest)
{
Dispatcher dispatcher = new Dispatcher();
dispatcher.RegisterInterceptor(new LoggerInterceptor());
dispatcher.RegisterInterceptor(new InvokerInterceptor());
OrderValidation orderValidation = new OrderValidation(new RepositoryFactory <OrderEntity>(), _appSettings.Value.MongoConnectionString, dispatcher, new Logger(), new Invoker());
try
{
var orderValidationStatus = orderValidation.ValidateOrder(orderRequest.AccountName,
orderRequest.CustomerName, orderRequest.Products);
orderValidation.AddOrderToRepository(orderValidationStatus.OrderEntity);
return(new OrderResponse()
{
Message = "Order Complete",
OrderComplete = orderValidationStatus.IsValid,
OrderEntity = orderValidationStatus.OrderEntity
});
}
catch (Exception e)
{
return(new OrderResponse()
{
Message = "Order Not Complete",
OrderComplete = false
});
}
}
public void MorningDessertRuleIsFalse()
{
IOrder order = new Order();
order.SetTimeOfDay(Enums.TimeOfDay.Morning);
Assert.IsFalse(OrderValidation.ValidateMorningDessertRule(order, Enums.DishTypes.Dessert));
}
private async Task FillAnOrder(ConversationFlow flow, OrderInfo profile, ITurnContext <IMessageActivity> turnContext)
{
string input = turnContext.Activity.Text?.Trim();
string message;
switch (flow.LastQuestionAsked)
{
case ConversationFlow.Question.None:
await turnContext.SendActivityAsync("Let's get started. What is your name?");
flow.LastQuestionAsked = ConversationFlow.Question.Name;
break;
case ConversationFlow.Question.Name:
if (OrderValidation.ValidateName(input, out string name, out message))
{
profile.Name = name;
await turnContext.SendActivityAsync($"Hi {profile.Name}.");
await turnContext.SendActivityAsync("How old are you?");
flow.LastQuestionAsked = ConversationFlow.Question.Age;
break;
}
else
{
await turnContext.SendActivityAsync(message ?? "I'm sorry, I didn't understand that.");
break;
}
static void Main(string[] args)
{
Console.WriteLine("Enter a Product Id: ");
string id = Console.ReadLine();
Console.WriteLine("The Product Id is {0}", OrderValidation.IsProductIdValid(id) ? "valid" : "invalid");
Console.ReadKey();
}
public override bool IsValid()
{
var orderValidation = new OrderValidation().Validate(this);
if (!orderValidation.IsValid)
{
this.SetValidation(orderValidation);
}
return(orderValidation.IsValid);
}
public JsonResult AddOrder(OrderValidation order)
{
if (ModelState.IsValid)
{
using (OrdersData db = new OrdersData())
{
return(Json(db.Add(order)));
}
}
return(Json(false));
}
public JsonResult UpdateOrder(OrderValidation order, int id)
{
if (ModelState.IsValid)
{
using (OrdersData db = new OrdersData())
{
return(Json(db.Update(_order => _order.Id == id, order)));
}
}
return(Json(false));
}
public (bool isValid, IEnumerable <ValidationResult> errors) Validate()
{
var validator = new OrderValidation();
var result = validator.Validate(this);
if (result.IsValid)
{
return(true, null);
}
return(false, result.Errors.Select(item => new ValidationResult(item.ErrorMessage, new[] { item.PropertyName })));
}
private void buttonAddToList_Click(object sender, EventArgs e)
{
Order order = new Order();
if (OrderValidation.isValidID(textboxOrderId) && OrderValidation.isValidClient(textboxClientId) && OrderValidation.isValidBooks(textboxBookId) && OrderValidation.isValidValues(textboxbQuantity))
{
order.OrderID = Convert.ToInt32(textboxOrderId.Text);
order.ClientID = Convert.ToInt32(textboxClientId.Text);
order.BookID = Convert.ToInt64(textboxBookId.Text);
order.Quantity = Convert.ToInt32(textboxbQuantity.Text);
OrderDA.Add(order);
ClearAll();
}
}
public ActionResult Update(Order entity)
{
ValidationResult result = new OrderValidation().Validate(entity, ruleSet: "Add");
MsgModel model;
if (result.IsValid)
{
model = new MsgModel(Ioc.Get <IOrderService>().Update(entity));
}
else
{
model = new MsgModel(result);
}
return(Json(model, JsonRequestBehavior.AllowGet));
}
public override bool IsValid()
{
ValidationResult = new OrderValidation().Validate(this);
_items.ToList().ForEach(x =>
{
if (!x.IsValid())
{
AddValidationResults(x.ValidationResult);
}
AddNotifications(x.Notifications);
});
return(ValidationResult.IsValid && !HasNotifications);
}
public Result PlaceOrder(OrderRequest order)
{
var result = new OrderValidation().Validate(order);
if (result.Success)
{
Orders.Add(order);
result.Id = Orders.Count;
}
WebOperationContext.Current.OutgoingResponse.StatusCode = result.Success
? HttpStatusCode.Created
: HttpStatusCode.BadRequest;
return(result);
}
/// <summary>
/// Process dishes in the order list.
/// It will validate multiple dishes rule and increment the dish's counter.
/// </summary>
/// <param name="order">The order wich will be processed.</param>
/// <param name="inputString">Input string with order info.</param>
/// <returns>Returns true if process completes ok, or false if not.</returns>
public static bool ProcessDishes(IOrder order, string inputString)
{
try
{
if (order == null)
{
return(false);
}
Enums.DishTypes dishType = GetDishType(inputString);
if (dishType == Enums.DishTypes.Error)
{
order.SetError();
return(false);
}
if (OrderValidation.ValidateMultipleDishes(order, dishType))
{
// If dish allows multiple choices, increment counter
order.DishCounter(dishType, true);
}
else
{
// If dish doesn't allow multiple choices, but counter is 0 AND
// is not dessert on morning, increment counter
if (order.DishCounter(dishType) == 0 && OrderValidation.ValidateMorningDessertRule(order, dishType))
{
order.DishCounter(dishType, true);
}
else
{
// Otherwise, set error in the order
order.SetError();
return(false);
}
}
return(true);
}
catch (Exception)
{
order.SetError();
return(false);
}
}
public void TimeOfDayIsFalseWithNullOrder()
{
Assert.IsFalse(OrderValidation.ValidateTimeOfDay(null, "morning"));
}
private void btnSubmit_Click(object sender, RoutedEventArgs e)
{
SqlConnection sqlCon = new SqlConnection(@"Data Source=(local); Initial Catalog=Zadatak_1; Integrated Security=True;");
try
{
//User is extracted from the database matching inserted paramaters Username and Password.
SqlCommand query = new SqlCommand("SELECT * FROM tblUser WHERE Username=@Username AND Password=@Password", sqlCon);
query.CommandType = CommandType.Text;
query.Parameters.AddWithValue("@Username", txtUsername.Text);
query.Parameters.AddWithValue("@Password", txtPassword.Password);
sqlCon.Open();
SqlDataAdapter sqlDataAdapter = new SqlDataAdapter(query);
DataTable dataTable = new DataTable();
sqlDataAdapter.Fill(dataTable);
User user = new User();
foreach (DataRow row in dataTable.Rows)
{
user = new User
{
Id = int.Parse(row[0].ToString()),
Username = row[1].ToString(),
Password = row[2].ToString()
};
}
//If username is as value below, Employe window is engaged.
if (user.Username == "Zaposleni")
{
EmployeWindow dashboard = new EmployeWindow();
dashboard.Show();
this.Close();
}
//If username is as value below, User window is engaged.
else if (user.Password == "Gost")
{
//Validation if user has pending order to be approved.
if (!OrderValidation.UserHasOrder(user))
{
UserWindow dashboard = new UserWindow(user);
dashboard.Show();
this.Close();
}
else
{
//If user has order with pending approval, application exits to the login screen.
return;
}
}
else
{
MessageBox.Show("Username or password is incorrect.");
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
finally
{
sqlCon.Close();
}
}
public OrderService(IOrderRepository orderRepository)
{
_orderRepository = orderRepository;
_orderValidator = new OrderValidation(_orderRepository);
}
private void btnSubmit_Click(object sender, RoutedEventArgs e)
{
SqlConnection sqlCon = new SqlConnection(ConfigurationManager.ConnectionStrings["con"].ToString());
try
{
//User is extracted from the database matching inserted paramaters Username and Password.
SqlCommand query = new SqlCommand("SELECT * FROM tblUser WHERE Username=@Username", sqlCon);
query.CommandType = CommandType.Text;
query.Parameters.AddWithValue("@Username", txtUsername.Text);
sqlCon.Open();
SqlDataAdapter sqlDataAdapter = new SqlDataAdapter(query);
DataTable dataTable = new DataTable();
sqlDataAdapter.Fill(dataTable);
User user = new User();
foreach (DataRow row in dataTable.Rows)
{
user = new User
{
Id = int.Parse(row[0].ToString()),
Username = row[1].ToString(),
Password = row[2].ToString()
};
}
//If username is as value below, Employe window is engaged.
if (user.Username == "Zaposleni" && user.Password == "Zaposleni" && txtPassword.Password == "Zaposleni")
{
EmployeWindow dashboard = new EmployeWindow();
dashboard.Show();
this.Close();
return;
}
//If username is as value below, User window is engaged.
else if (txtPassword.Password == "Gost" && user.Password == "Gost" && user.Username != null)
{
//Validation if user has pending order to be approved.
if (!OrderValidation.UserHasOrder(user))
{
UserWindow dashboard = new UserWindow(user);
dashboard.Show();
this.Close();
return;
}
else
{
//If user has order with pending approval, application exits to the login screen.
return;
}
}
else if (txtPassword.Password != "Gost" && user.Username != null)
{
MessageBoxResult messageBoxResult = System.Windows.MessageBox.Show("Incorrect password, please try again.", "Notification");
return;
}
else
{
user = new User(txtUsername.Text, txtPassword.Password);
//If all inputs are correct, user will be added to the database.
if (AddUserValidation.Validate(user))
{
using (var conn = new SqlConnection(ConfigurationManager.ConnectionStrings["con"].ToString()))
{
var cmd = new SqlCommand(@"insert into tblUser values (@Username, @Password); SELECT SCOPE_IDENTITY();", conn);
cmd.Parameters.AddWithValue("@Username", txtUsername.Text);
cmd.Parameters.AddWithValue("@Password", txtPassword.Password);
conn.Open();
cmd.ExecuteNonQuery();
user.Id = Convert.ToInt32(cmd.ExecuteScalar());
conn.Close();
MessageBoxResult messageBoxResult = System.Windows.MessageBox.Show("User Successfully created.", "Notification");
UserWindow dashboard = new UserWindow(user);
dashboard.Show();
this.Close();
}
}
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
finally
{
sqlCon.Close();
}
}
public void TimeOfDayIsTrue()
{
IOrder order = new Order();
Assert.IsTrue(OrderValidation.ValidateTimeOfDay(order, "morning"));
}
public void MorningDessertRuleIsFalseWithNullOrder()
{
Assert.IsFalse(OrderValidation.ValidateMorningDessertRule(null, Enums.DishTypes.Entree));
}
//reads the batch order file and returns
//an array list of orders
private ArrayList processFile(string fileName, out List <CustomError> alWarnings)
{
alWarnings = new List <CustomError>();
bool bValid = true;
ArrayList alOrders = null;
string csvFileName = null;
//no conversion needed if .csv
if (fileName.Contains(".csv"))
{
csvFileName = fileName;
}
else
{
//convert to .csv
ApplicationClass ExcelApp = null;
try
{
ExcelApp = new ApplicationClass();
Workbook uploadedWorkBook = ExcelApp.Workbooks.Open(fileName,
Type.Missing, Type.Missing, Type.Missing, Type.Missing,
Type.Missing, Type.Missing, Type.Missing, Type.Missing,
Type.Missing, Type.Missing, Type.Missing, Type.Missing,
Type.Missing, Type.Missing);
csvFileName = fileName + ".csv";
File.Delete(csvFileName);
uploadedWorkBook.SaveAs(csvFileName, XlFileFormat.xlCSV,
Type.Missing, Type.Missing,
Type.Missing, Type.Missing,
XlSaveAsAccessMode.xlExclusive, Type.Missing,
Type.Missing, Type.Missing, Type.Missing, Type.Missing);
uploadedWorkBook.Close(false, csvFileName, false);
}
catch (Exception e)
{
bValid = false;
Validators.Add(new CustomError("Error processing .xls file. Contact customer support. Error code 1"));
EventLog woeLog = new EventLog("WebOrderEntry");
woeLog.Source = "WebOrderEntryApp";
string errorMessage = "Message\r\n" + e.Message.ToString() + "\r\n\r\n";
errorMessage += "Source\r\n" + e.Source + "\r\n\r\n";
errorMessage += "Target site\r\n" + e.TargetSite.ToString() + "\r\n\r\n";
errorMessage += "Stack trace\r\n" + e.StackTrace + "\r\n\r\n";
errorMessage += "ToString()\r\n\r\n" + e.ToString();
woeLog.WriteEntry(errorMessage, EventLogEntryType.Error, 1);
return(null);
}
finally
{
if (ExcelApp != null)
{
ExcelApp.Workbooks.Close();
ExcelApp.Quit();
}
}
}
alOrders = new ArrayList();
warehouse_shipping_ordersWarehouse_shipping_order eachOrder = null;
OrderValidation orderValidation = null;
int iCurrentRow = 1;
string sCurrentRow = "1";
// open the file which is a CSV file with no headers
using (CsvReader csv = new CsvReader(new StreamReader(csvFileName), false))
{
int fieldCount = csv.FieldCount;
//string[] headers = csv.GetFieldHeaders();
while (csv.ReadNextRecord())
{
string sEachSegment = csv[0].Trim();
switch (sEachSegment)
{
case "HDR":
#region validateHeader
// New Order
if (orderValidation != null)
{
eachOrder = orderValidation.getOrder(sCurrentRow);
if (eachOrder != null)
{
alOrders.Add(eachOrder);
}
else
{
bValid = false;
//Validators.Add(new CustomError("Invalid " + HDR + " field count=" + dr.FieldCount.ToString() + " should be " + HDR_FIELDCOUNT.ToString() + " row " + iCurrentRow + " column A."));
break;
}
}
orderValidation = new OrderValidation(Validators);
//set account id from session
if (Session["AccountId"] != null)
{
orderValidation.AccountId = (string)Session["AccountId"];
}
//process header record
//check field count
if (csv.FieldCount < HDR_FIELDCOUNT)
{
bValid = false;
Validators.Add(new CustomError("Invalid " + HDR + " field count=" + csv.FieldCount.ToString() +
" should be " + HDR_FIELDCOUNT.ToString() + " row " + iCurrentRow + " column A."));
break;
}
List <CustomError> eachOrderWarningList = orderValidation.validateHeader(csv, sCurrentRow, out bValid);
if (eachOrderWarningList.Count > 0)
{
foreach (CustomError warning in eachOrderWarningList)
{
alWarnings.Add(warning);
}
}
if (bValid == false)
{
break;
}
#endregion
break;
case "LOC":
#region validateLoc
//process address record
//check field count
if (csv.FieldCount < LOC_FIELDCOUNT)
{
bValid = false;
Validators.Add(new CustomError("Invalid " + LOC + " field count=" + csv.FieldCount.ToString() + " should be " + LOC_FIELDCOUNT.ToString() + " row " + iCurrentRow + " column A."));
break;
}
if (!orderValidation.validateLoc(csv, sCurrentRow))
{
bValid = false;
break;
}
#endregion
break;
case "DET":
#region validateDetail
//process detail record
//check field count
if (csv.FieldCount < DET_FIELDCOUNT)
{
bValid = false;
Validators.Add(new CustomError("Invalid " + DET + " field count=" + csv.FieldCount.ToString() + " should be " + DET_FIELDCOUNT.ToString() + " row " + iCurrentRow + " column A."));
break;
}
if (!orderValidation.validateDetail(csv, sCurrentRow))
{
bValid = false;
break;
}
#endregion
break;
case "ASN":
#region validateASN
//process asn record
//check field count
if (csv.FieldCount < ASN_FIELDCOUNT)
{
bValid = false;
Validators.Add(new CustomError("Invalid " + ASN + " field count=" + csv.FieldCount.ToString() + " should be " + ASN_FIELDCOUNT.ToString() + " row " + iCurrentRow + " column A."));
break;
}
if (!orderValidation.validateAsn(csv, sCurrentRow))
{
bValid = false;
break;
}
#endregion
break;
case "REF":
#region validateRefNbr
//process header reference record
//check field count
if (csv.FieldCount < REF_FIELDCOUNT)
{
bValid = false;
Validators.Add(new CustomError("Invalid " + REF + " field count=" + csv.FieldCount.ToString() + " should be " + REF_FIELDCOUNT.ToString() + " row " + iCurrentRow + " column A."));
break;
}
if (!orderValidation.validateRef(csv, sCurrentRow))
{
bValid = false;
break;
}
#endregion
break;
case "NTE":
#region validateRefNbr
//process note record
//check field count
if (csv.FieldCount < NTE_FIELDCOUNT)
{
bValid = false;
Validators.Add(new CustomError("Invalid " + NTE + " field count=" + csv.FieldCount.ToString() + " should be " + NTE_FIELDCOUNT.ToString() + " row " + iCurrentRow + " column A."));
break;
}
if (!orderValidation.validateNote(csv, sCurrentRow))
{
bValid = false;
break;
}
#endregion
break;
default:
bValid = false;
Validators.Add(new CustomError("Invalid Segment Name" + sEachSegment + " - row " + iCurrentRow + " column A."));
break;
}
iCurrentRow++;
sCurrentRow = Convert.ToString(iCurrentRow);
}
}
//done with csv file, delete it
File.Delete(csvFileName);
//}
//check/add the last order
if (bValid)
{
eachOrder = orderValidation.getOrder(sCurrentRow);
if (eachOrder != null)
{
alOrders.Add(eachOrder);
}
else
{
bValid = false;
}
}
//return the validated orders arraylist
if (bValid)
{
return(alOrders);
}
else
{
return(null);
}
}
public void TestInitialize()
{
_orderRepository = new OrderRepositoryMock();
_orderValidation = new OrderValidation(_orderRepository);
}
public void TimeOfDayIsFalseWithInvalidTimeOfDay()
{
IOrder order = new Order();
Assert.IsFalse(OrderValidation.ValidateTimeOfDay(order, ""));
}
