/// <summary>
/// Gets supported values by element.
/// </summary>
/// <param name="element">OrderPriority element.</param>
/// <returns>Array of supported values.</returns>
static private string _GetSupportedValues(OrderPriority element)
{
string supportedValues = null;
switch (element)
{
case OrderPriority.High:
supportedValues = Properties.Resources.OrderPriorityHighSupportedValues;
break;
case OrderPriority.Normal:
supportedValues = Properties.Resources.OrderPriorityNormalSupportedValues;
break;
case OrderPriority.Low:
supportedValues = Properties.Resources.OrderPriorityLowSupportedValues;
break;
case OrderPriority.Urgent:
supportedValues = Properties.Resources.OrderPriorityUrgentSupportedValues;
break;
default:
Debug.Assert(false); // NOTE: not supported
break;
}
return(supportedValues);
}
public Order(Customer c, CarModel m, OrderPriority priority = OrderPriority.Normal)
{
this.Customer = c;
this.Model = m;
// Orders have a Normal priority by default.
this.ChangeOrderPriority(priority);
}
/// <summary>
/// Convert Enum value to string.
/// </summary>
/// <param name="value">Enum value, which must be converted.</param>
/// <param name="targetType">Ignored.</param>
/// <param name="parameter">Ignored.</param>
/// <param name="culture">Ignored.</param>
/// <returns><c>String</c> representing enum's value.</returns>
public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
{
string result = string.Empty;
// If value isnt null - convert.
if (value != null)
{
OrderPriority syncType = (OrderPriority)value;
switch (syncType)
{
// Convert selected synctype to it's string representation.
case OrderPriority.High:
result = App.Current.GetString("OrderPriorityHigh");
break;
case OrderPriority.Normal:
result = App.Current.GetString("OrderPriorityNormal");
break;
default:
// Not supported Enum value.
Debug.Assert(false);
break;
}
}
return(result);
}
public ActionResult DeleteConfirmed(int id)
{
OrderPriority orderPriority = db.OrderPriorities.Find(id);
db.OrderPriorities.Remove(orderPriority);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public ActionResult Edit([Bind(Include = "Id,PriorityName,PriorityDescription")] OrderPriority orderPriority)
{
if (ModelState.IsValid)
{
db.Entry(orderPriority).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(orderPriority));
}
public ActionResult Create([Bind(Include = "Id,PriorityName,PriorityDescription")] OrderPriority orderPriority)
{
if (ModelState.IsValid)
{
db.OrderPriorities.Add(orderPriority);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(orderPriority));
}
public static Line54OrderInformation Create(int rackNumber, int tubeNumber, OrderPriority orderPriority, string leaderText1 = "", string leaderText2 = "")
{
return(new Line54OrderInformation()
{
SamplePositionRackNumber = rackNumber,
SamplePositionTubeNumber = tubeNumber,
OrderPriority = orderPriority,
SampleLeaderText1 = leaderText1,
SampleLeaderText2 = leaderText2
});
}
public PageParseOrderDTO TryToStartNewParse(string url, OrderPriority priority)
{
var parseOrder = GetParseOrderByUrl(url);
if (parseOrder != null)
{
return(parseOrder);
}
return(StartNewParse(url, priority));
}
public void ChangePriority(OrderPriority priority, IClock clock)
{
if (Priority == priority)
{
return;
}
var originalPriority = Priority;
Priority = priority;
DomainEvents.Add(new OrderPriorityChangedEvent(this, originalPriority, clock));
}
// GET: OrderPriorities/Delete/5
public ActionResult Delete(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
OrderPriority orderPriority = db.OrderPriorities.Find(id);
if (orderPriority == null)
{
return(HttpNotFound());
}
return(View(orderPriority));
}
public PageParseOrderDTO StartNewParse(string url, OrderPriority priority)
{
var newParseOrder = new PageParseOrderDTO()
{
OrderCreated = DateTime.Now,
OrderGUID = Guid.NewGuid().ToString(),
Url = url,
Priority = priority
};
lock (_queueOfOrdersToParse)
{
_queueOfOrdersToParse.Add(newParseOrder);
}
return(newParseOrder);
}
public override int GetHashCode()
{
unchecked
{
var hash = 17;
hash = hash * 29 + MessageType.GetHashCode();
hash = hash * 29 + Symbol.GetHashCode();
hash = hash * 29 + OrderId.GetHashCode();
hash = hash * 29 + MMID.GetHashCode();
hash = hash * 29 + Side.GetHashCode();
hash = hash * 29 + Price.GetHashCode();
hash = hash * 29 + Size.GetHashCode();
hash = hash * 29 + OrderPriority.GetHashCode();
hash = hash * 29 + Precision.GetHashCode();
hash = hash * 29 + OrderTime.GetHashCode();
hash = hash * 29 + OrderDate.GetHashCode();
return(hash);
}
}
/// <summary>
/// Changes the priority of the current order.
/// </summary>
/// <param name="priority">The new priority that should be assigned.</param>
public void ChangeOrderPriority(OrderPriority priority)
{
this.Priority = priority;
// Open connection to database
using (MySqlConnection con = ApplicationSettings.GetConnection())
{
con.Open();
// Change order's priority in database
MySqlCommand cmd = new MySqlCommand("UPDATE `order` SET `priority`= @p where `order_id`= @id;", con);
cmd.Parameters.AddWithValue("@p", this.Priority);
cmd.Parameters.AddWithValue("@id", this.ID);
cmd.ExecuteNonQuery();
// Close connection
con.Close();
}
}
/// <summary>
/// Constructor that does not specify an explicit list of procedures.
/// </summary>
/// <param name="enteredTime"></param>
/// <param name="enteredBy"></param>
/// <param name="enteredComment"></param>
/// <param name="accessionNumber"></param>
/// <param name="patient"></param>
/// <param name="visit"></param>
/// <param name="diagnosticService"></param>
/// <param name="reasonForStudy"></param>
/// <param name="priority"></param>
/// <param name="orderingFacility"></param>
/// <param name="performingFacility"></param>
/// <param name="schedulingRequestTime"></param>
/// <param name="orderingPractitioner"></param>
/// <param name="resultRecipients"></param>
public OrderCreationArgs(DateTime enteredTime, Staff enteredBy, string enteredComment, string accessionNumber,
Patient patient, Visit visit, DiagnosticService diagnosticService, string reasonForStudy, OrderPriority priority,
Facility orderingFacility, Facility performingFacility, DateTime?schedulingRequestTime, ExternalPractitioner orderingPractitioner,
IList <ResultRecipient> resultRecipients)
{
EnteredTime = enteredTime;
EnteredBy = enteredBy;
EnteredComment = enteredComment;
AccessionNumber = accessionNumber;
Patient = patient;
Visit = visit;
DiagnosticService = diagnosticService;
ReasonForStudy = reasonForStudy;
Priority = priority;
OrderingFacility = orderingFacility;
PerformingFacility = performingFacility;
SchedulingRequestTime = schedulingRequestTime;
OrderingPractitioner = orderingPractitioner;
ResultRecipients = resultRecipients;
}
/// <summary>
/// Constructor that does not specify an explicit list of procedures.
/// </summary>
/// <param name="enteredTime"></param>
/// <param name="enteredBy"></param>
/// <param name="enteredComment"></param>
/// <param name="accessionNumber"></param>
/// <param name="patient"></param>
/// <param name="visit"></param>
/// <param name="diagnosticService"></param>
/// <param name="reasonForStudy"></param>
/// <param name="priority"></param>
/// <param name="orderingFacility"></param>
/// <param name="performingFacility"></param>
/// <param name="schedulingRequestTime"></param>
/// <param name="orderingPractitioner"></param>
/// <param name="resultRecipients"></param>
public OrderCreationArgs(DateTime enteredTime, Staff enteredBy, string enteredComment, string accessionNumber,
Patient patient, Visit visit, DiagnosticService diagnosticService, string reasonForStudy, OrderPriority priority,
Facility orderingFacility, Facility performingFacility, DateTime? schedulingRequestTime, ExternalPractitioner orderingPractitioner,
IList<ResultRecipient> resultRecipients)
{
EnteredTime = enteredTime;
EnteredBy = enteredBy;
EnteredComment = enteredComment;
AccessionNumber = accessionNumber;
Patient = patient;
Visit = visit;
DiagnosticService = diagnosticService;
ReasonForStudy = reasonForStudy;
Priority = priority;
OrderingFacility = orderingFacility;
PerformingFacility = performingFacility;
SchedulingRequestTime = schedulingRequestTime;
OrderingPractitioner = orderingPractitioner;
ResultRecipients = resultRecipients;
}
/// <summary>
/// Adds a new action to the agent cursor controller.
/// </summary>
/// <param name="action">The cursor action to perform.</param>
/// <param name="priority">When should this action be performed.</param>
public void AddAction(CursorAction action, OrderPriority priority)
{
// Check for invalid action.
if (action.path == null)
{
throw new ArgumentNullException("action.path", "Path must have at least two points.");
}
else if (action.path.Length < 2)
{
throw new ArgumentException("Path must have at least two points.", "action.path");
}
if (isEnabled)
{
// Add the action based on the action
// priority.
switch (priority)
{
case OrderPriority.Queued:
actions.Add(action);
break;
case OrderPriority.Immediate:
actions.Insert(0, action);
break;
default:
// Throw if order priority enum is updated,
// but the appropriate behavior has not been
// added for this switch block.
throw new NotImplementedException();
}
// If the controller is not performing an
// action, start its Update routine.
if (actionState == ActionState.AwaitingAction)
{
PullAction();
}
}
}
private void InsertTestData(ApplicationDbContext context)
{
if (!context.Countries.Any())
{
List <CountryDto> countries = TestDataGenerator.TestDataGenerator.GenerateCountries();
foreach (var country in countries)
{
Country newCountry = new Country()
{
CountryName = country.CountryName
};
context.Countries.Add(newCountry);
}
}
if (!context.Regions.Any())
{
List <RegionDto> regions = TestDataGenerator.TestDataGenerator.GenerateRegions();
foreach (var item in regions)
{
Region newItem = new Region()
{
RegionName = item.RegionName
};
context.Regions.Add(newItem);
}
}
if (!context.OrderPriorities.Any())
{
List <OrderPriorityDto> orderPriorities = TestDataGenerator.TestDataGenerator.GenerateOrderPriorities();
foreach (var item in orderPriorities)
{
OrderPriority newItem = new OrderPriority()
{
OrderPriorityName = item.OrderPriorityName
};
context.OrderPriorities.Add(newItem);
}
}
if (!context.SalesChannels.Any())
{
List <SalesChannelDto> salesChannels = TestDataGenerator.TestDataGenerator.GenerateSalesChannels();
foreach (var item in salesChannels)
{
SalesChannel newItem = new SalesChannel()
{
SalesChannelName = item.SalesChannelName
};
context.SalesChannels.Add(newItem);
}
}
if (!context.ItemTypes.Any())
{
List <ItemTypeDto> itemTypes = TestDataGenerator.TestDataGenerator.GenerateItemTypes();
foreach (var item in itemTypes)
{
ItemType newItem = new ItemType()
{
ItemTypeName = item.ItemTypeName
};
context.ItemTypes.Add(newItem);
}
}
}
public void setPriority_of_order(OrderPriority priority_of_order)
{
this.priority_of_order = priority_of_order;
}
static async Task SaveRecordFromCsv(CsvReader csvReader, int index)
{
var regionKey = csvReader.GetField("Region");
Region region;
if (regionKeys.Contains(regionKey))
{
region = regions.First(region => region.Name == regionKey);
}
else
{
regionKeys.Add(regionKey);
region = new Region {
Name = regionKey
};
regions.Add(region);
}
var countryKey = csvReader.GetField("Country");
Country country;
if (countriesKeys.Contains(countryKey))
{
country = countries.First(country => country.Name == countryKey);
country.Region = region;
}
else
{
countriesKeys.Add(countryKey);
country = new Country
{
Name = countryKey,
Region = region
};
countries.Add(country);
}
var itemKey = csvReader.GetField("Item Type");
Item item;
if (itemKeys.Contains(itemKey))
{
item = items.First(item => item.Name == itemKey);
}
else
{
itemKeys.Add(itemKey);
item = new Item {
Name = itemKey
};
items.Add(item);
}
var orderPriorityKey = csvReader.GetField("Order Priority");
OrderPriority orderPriority;
if (orderPriorityKeys.Contains(orderPriorityKey))
{
orderPriority = orderPriorities.First(orderPriority => orderPriority.Symbol == orderPriorityKey);
}
else
{
orderPriorityKeys.Add(orderPriorityKey);
orderPriority = new OrderPriority {
Symbol = orderPriorityKey
};
orderPriorities.Add(orderPriority);
}
var orderKey = csvReader.GetField <int>("Order ID");
Order order;
if (orderKeys.Contains(orderKey))
{
order = orders.First(order => order.Id == orderKey);
}
else
{
orderKeys.Add(orderKey);
order = new Order
{
Id = orderKey,
OrderedAt = csvReader.GetField <DateTime>("Order Date"),
OrderPriority = orderPriority
};
orders.Add(order);
}
var sale = new Sale
{
SalesChannel = csvReader.GetField("Sales Channel"),
ShippedAt = csvReader.GetField <DateTime>("Ship Date"),
UnitsSold = csvReader.GetField <int>("Units Sold"),
UnitPrice = csvReader.GetField <decimal>("Unit Price"),
UnitCost = csvReader.GetField <decimal>("Unit Cost"),
TotalRevenue = csvReader.GetField <decimal>("Total Revenue"),
TotalCost = csvReader.GetField <decimal>("Total Cost"),
TotalProfit = csvReader.GetField <decimal>("Total Profit"),
Order = order,
Item = item,
Country = country
};
sales[index] = sale;
if (index == _chunkSize - 1)
{
_dbContext.Sales.AddRange(sales.ToList().Take(_chunkSize));
await _dbContext.SaveChangesAsync();
_arrayPool.Return(sales, true);
sales = _arrayPool.Rent(_chunkSize);
Console.WriteLine($"Chunk {_currentChunkNo + 1} was saved.");
_currentChunkNo += 1;
}
}
/// <summary>
/// Creates and places an order with the specified <paramref name="customer"/> and
/// <paramref name="model"/>. Optionally, there can be a priority, but by default it is <see cref="OrderPriority.Normal"/>.
/// </summary>
/// <param name="customer">The customer of the order.</param>
/// <param name="model"></param>
/// <param name="op"></param>
public void OrderModel(Customer customer, CarModel model, OrderPriority op = OrderPriority.Normal)
{
this.PlaceOrder(new Order(customer, model, op));
}
/// <summary>
/// Gets supported values by element.
/// </summary>
/// <param name="element">OrderPriority element.</param>
/// <returns>Array of supported values.</returns>
private static string _GetSupportedValues(OrderPriority element)
{
string supportedValues = null;
switch (element)
{
case OrderPriority.High:
supportedValues = Properties.Resources.OrderPriorityHighSupportedValues;
break;
case OrderPriority.Normal:
supportedValues = Properties.Resources.OrderPriorityNormalSupportedValues;
break;
default:
Debug.Assert(false); // NOTE: not supported
break;
}
return supportedValues;
}
internal void SaveToDataBase()
{
LinnWorks.Models.Import import = new LinnWorks.Models.Import();
import.LastModifyUserId = user_id;
import.LastModifyDttm = DateTime.UtcNow;
foreach (DataRow oRow in values.Rows)
{
string regionName = oRow["Region"].ToString();
string countryName = oRow["Country"].ToString();
string itemTypeName = oRow["Item Type"].ToString();
string orderPriorityName = oRow["Order Priority"].ToString();
int orderIdExt = Convert.ToInt32(oRow["Order ID"]);
LinnWorks.Models.Order order = new LinnWorks.Models.Order();
if (context.Orders.Where(x => x.OrderIdExt == orderIdExt).Any())
{
order = context.Orders.Where(x => x.OrderIdExt == orderIdExt).FirstOrDefault();
}
else
{
context.Orders.Add(order);
}
order.OrderDate = Convert.ToDateTime(oRow["Order Date"]);
order.OrderIdExt = orderIdExt;
order.ShipDate = Convert.ToDateTime(oRow["Ship Date"]);
order.UnitsSold = Convert.ToInt32(oRow["Units Sold"]);
order.UnitPrice = Convert.ToDouble(oRow["Unit Cost"]);
order.TotalRevenue = Convert.ToDouble(oRow["Total Revenue"]);
order.TotalCost = Convert.ToDouble(oRow["Total Cost"]);
order.TotalProfit = Convert.ToDouble(oRow["Total Profit"]);
order.LastModifyDttm = DateTime.UtcNow;
order.LastModifyUserId = user_id;
Region region = new Region();
if (!context.Regions.Where(x => x.Name == regionName).Any())
{
region.Name = regionName;
region.LastModifyDttm = DateTime.UtcNow;
region.LastModifyUserId = user_id;
context.Regions.Add(region);
}
else
{
region = context.Regions.Where(x => x.Name == regionName).FirstOrDefault();
}
region.Orders.Add(order);
LinnWorks.Models.Country country = new LinnWorks.Models.Country();
if (!context.Countries.Where(x => x.Name == countryName).Any())
{
country.Name = countryName;
country.LastModifyDttm = DateTime.UtcNow;
country.LastModifyUserId = user_id;
context.Countries.Add(country);
}
else
{
country = context.Countries.Where(x => x.Name == countryName).FirstOrDefault();
}
country.Orders.Add(order);
ItemType itemType = new ItemType();
if (!context.ItemTypes.Where(x => x.Name == itemTypeName).Any())
{
itemType.Name = itemTypeName;
itemType.LastModifyDttm = DateTime.UtcNow;
itemType.LastModifyUserId = user_id;
context.ItemTypes.Add(itemType);
}
else
{
itemType = context.ItemTypes.Where(x => x.Name == itemTypeName).FirstOrDefault();
}
itemType.Orders.Add(order);
OrderPriority orderPriority = new OrderPriority();
if (!context.OrderPriorities.Where(x => x.name == orderPriorityName).Any())
{
orderPriority.name = orderPriorityName;
orderPriority.LastModifyDttm = DateTime.UtcNow;
orderPriority.LastModifyUserId = user_id;
context.OrderPriorities.Add(orderPriority);
}
else
{
orderPriority = context.OrderPriorities.Where(x => x.name == orderPriorityName).FirstOrDefault();
}
orderPriority.Orders.Add(order);
import.Orders.Add(order);
}
context.Imports.Add(import);
context.SaveChanges();
}
public async Task ImportAsync(IEnumerable <SaleDto> sales, CancellationToken cancellationToken)
{
var itemKeys = sales
.Select(sale => sale.ItemName)
.Distinct();
var countryKeys = sales
.Select(sale => sale.CountryName)
.Distinct();
var regionKeys = sales
.Select(sale => sale.CountryRegionName)
.Distinct();
var orderPriorityKeys = sales
.Select(sale => sale.OrderPrioritySymbol)
.Distinct();
var items = new Dictionary <string, Item>();
var countries = new Dictionary <string, Country>();
var regions = new Dictionary <string, Region>();
var orderPriorities = new Dictionary <string, OrderPriority>();
async Task itemsRead()
{
items = await _dbContext.Items
.Where(item => itemKeys.Contains(item.Name))
.ToDictionaryAsync(item => item.Name);
}
async Task countriesRead()
{
countries = await _dbContext.Countries
.Where(country => countryKeys.Contains(country.Name))
.ToDictionaryAsync(country => country.Name);
}
async Task regionsRead()
{
regions = await _dbContext.Regions
.Where(region => regionKeys.Contains(region.Name))
.ToDictionaryAsync(region => region.Name);
}
async Task orderPrioritiesRead()
{
orderPriorities = await _dbContext.OrderPriorities
.Where(orderPriority => orderPriorityKeys.Contains(orderPriority.Symbol))
.ToDictionaryAsync(orderPriority => orderPriority.Symbol);
}
await Task.WhenAll(new Task[]
{
itemsRead(),
countriesRead(),
regionsRead(),
orderPrioritiesRead()
});
var entities = new List <Sale>();
foreach (var sale in sales)
{
Item item;
Country country;
Region region;
OrderPriority orderPriority;
if (items.ContainsKey(sale.ItemName))
{
item = items[sale.ItemName];
}
else
{
item = new Item
{
Id = 0,
Name = sale.ItemName
};
items.Add(sale.ItemName, item);
}
if (regions.ContainsKey(sale.CountryRegionName))
{
region = regions[sale.CountryRegionName];
}
else
{
region = new Region
{
Id = 0,
Name = sale.CountryRegionName
};
regions.Add(sale.CountryRegionName, region);
}
if (countries.ContainsKey(sale.CountryName))
{
country = countries[sale.CountryName];
if (country.RegionId != region.Id)
{
country.Id = 0;
country.RegionId = region.Id;
country.Region = region;
}
}
else
{
country = new Country
{
Id = 0,
Name = sale.CountryName,
RegionId = region.Id,
Region = region
};
countries.Add(sale.CountryName, country);
}
if (orderPriorities.ContainsKey(sale.OrderPrioritySymbol))
{
orderPriority = orderPriorities[sale.OrderPrioritySymbol];
}
else
{
orderPriority = new OrderPriority
{
Id = 0,
Symbol = sale.OrderPrioritySymbol
};
orderPriorities.Add(sale.OrderPrioritySymbol, orderPriority);
}
var order = new Order
{
OrderedAt = sale.OrderedAt,
OrderPriority = orderPriority
};
entities.Add(new Sale
{
SalesChannel = sale.SalesChannel,
ShippedAt = sale.ShippedAt,
UnitsSold = sale.UnitsSold,
UnitPrice = sale.UnitPrice,
UnitCost = sale.UnitCost,
TotalRevenue = sale.TotalRevenue,
TotalCost = sale.TotalCost,
TotalProfit = sale.TotalProfit,
Order = order,
Item = item,
Country = country
});
}
_dbContext.Sales.AddRange(entities);
await _dbContext.SaveChangesAsync(cancellationToken);
}
public OrderPriorityChangedEvent(Order order, OrderPriority originalPriority, IClock clock)
{
Order = order;
OriginalPriority = originalPriority;
Timestamp = clock.UtcNow;
}