private void RegistFolder(string folderName, ParseHandler handler)
{
try
{
string filePath = Configure.cfgPath;
if (!File.Exists(Configure.cfgPath + folderName))
{
filePath = Configure.cfgPathStn;
}
string[] files = Directory.GetFiles(filePath.Replace("file:///", "") + folderName);
string fileName = "";
for (int i = 0; i < files.Length; ++i)
{
fileName = files[i].Substring(files[i].LastIndexOf("/"));
if (fileName.Contains(".xml"))
{
RegistTable(folderName + files[i].Substring(files[i].LastIndexOf("/")), handler);
}
}
}
catch (IOException e)
{
ClientLog.Instance.LogError(e.ToString());
}
}
/// <summary>
/// Tries parsing <paramref name="stringValue"/> into the specified return type.
/// </summary>
/// <param name="defaultValue">the default value to return if parsing fails</param>
/// <param name="stringValue">the string value to parse</param>
/// <returns>the successfully parsed value, <paramref name="defaultValue"/> otherwise.</returns>
public static T TryParse <T>(T defaultValue, string stringValue)
{
T result = defaultValue;
if (string.IsNullOrEmpty(stringValue))
{
return(defaultValue);
}
ParseHandler <T> parser = s_parsers[typeof(T)] as ParseHandler <T>;
if (parser == null)
{
throw new ArgumentException(string.Format("There is no parser registered for type {0}", typeof(T).FullName));
}
try
{
result = parser(stringValue);
}
catch
{
Trace.WriteLine(string.Format("WARN: failed converting value '{0}' to type '{1}' - returning default '{2}'", stringValue, typeof(T).FullName, result));
}
return(result);
}
public async Task <List <BusinessLogic.Objects.Product> > GetOrderProductListByID(int orderID)
{
try
{
List <Entities.OrderProduct> CTXOrdProdList = await _context.OrderProduct.AsNoTracking().Where(op => op.OrderId == orderID).ToListAsync();
List <BusinessLogic.Objects.Product> BLProdList = new List <BusinessLogic.Objects.Product>();
foreach (OrderProduct CTXOrdProd in CTXOrdProdList)
{
BLProdList.Add(ParseHandler.ContextOrderProductToLogicProduct(CTXOrdProd));
}
foreach (Entities.Product CTXProduct in _context.Product)
{
foreach (BusinessLogic.Objects.Product BLProd in BLProdList)
{
if (CTXProduct.ProductTypeId == BLProd.productTypeID)
{
BLProd.name = CTXProduct.ProductName;
}
}
}
return(BLProdList);
}
catch
{
throw new Exception("Failed to retrieve order product information for order ID: " + orderID);
}
}
protected T[] ParseValues <T>(string key, ParseHandler <T> handler)
where T : struct
{
var values = GetValue(key);
return(values.Select(v => handler(v)).ToArray());
}
public async Task <List <Order> > GetListAllOrdersForStore(int storeID)
{
try
{
List <BusinessLogic.Objects.Order> BLListOrders = new List <Order>();
foreach (Entities.Orders CTXOrder in _context.Orders.AsNoTracking().Where(o => o.StoreNumber == storeID).ToHashSet())
{
BLListOrders.Add(ParseHandler.ContextOrderToLogicOrder(CTXOrder));
}
foreach (BusinessLogic.Objects.Order BLOrd in BLListOrders)
{
BLOrd.StoreLocation = await GetStoreInformation(BLOrd.StoreLocation.storeNumber);
}
foreach (Order BLOrdToFill in BLListOrders)
{
BLOrdToFill.CustomerProductList = await GetOrderProductListByID(BLOrdToFill.orderID);
BLOrdToFill.Customer = await GetCustomerByID(BLOrdToFill.Customer.customerID);
}
return(BLListOrders);
}
catch
{
throw new Exception("Failed to retrieve order information for store number: " + storeID);
}
}
private SyntaxTree(SourceText text, ParseHandler handler)
{
Text = text;
handler(this, out var root, out var diagnostics);
Diagnostics = diagnostics;
Root = root;
}
public void FindFakeIngredientInContainerFail()
{
string input = "fake ingredient";
Ingredient returnedIngredient;
returnedIngredient = ParseHandler.findIngredient(input, testContainer);
Assert.IsNull(returnedIngredient);
}
private SyntaxTree(SourceFile file, ParseHandler handler)
{
File = file;
handler(this, out var root, out var diagnostics);
Root = root;
Diagnostics = diagnostics.ToImmutableArray();
}
public void ParseFractionCorrectly()
{
string input = "3/4";
double answer = -1;
answer = ParseHandler.measurementConversion(input);
Assert.AreEqual(answer, 0.75);
}
public void ParseNumberAndFractionCorrectly()
{
string input = "4 1/4";
double answer = -1;
answer = ParseHandler.measurementConversion(input);
Assert.AreEqual(answer, 4.25);
}
public void Test_Global_Var_Decls_002()
{
string src = Resources.Global_Var_Decls_002.GetString();
var result = ParseHandler.Parse(src);
string a = result.ParseTree.ToStringTree();
int b = 5;
}
private SyntaxTree(SourceText text, ParseHandler handler, string?filePath = null)
{
Text = text;
handler(this, out var root, out var diagnostics);
Diagnostics = new DiagnosticBag(diagnostics);
FilePath = filePath;
Root = root;
}
private void RegistTable(string name, ParseHandler handler)
{
if (parseFunc.ContainsKey(name))
{
ClientLog.Instance.LogError("more tables with same name!" + name);
return;
}
parseFunc [name] = handler;
}
public async Task <BusinessLogic.Objects.Customer> GetCustomerByID(int CustomerID)
{
try
{
return(ParseHandler.ContextCustomerToLogicCustomer(await _context.Customer.AsNoTracking().FirstAsync(c => c.CustomerId == CustomerID)));
}
catch (Exception e)
{
throw new Exception("Failed to retrieve customer information for customer ID: " + CustomerID + "\nException thrown: " + e.Message);
}
}
private SyntaxTree(SourceText text, ParseHandler handler)
{
this.Text = text;
var parser = new Parser(this);
handler(this, out var root, out var diagnostics);
this.Root = root;
this.Diagnostics = diagnostics;
}
protected T ParseValue <T>(string key, ParseHandler <T> handler)
where T : struct
{
var values = GetValue(key);
if (values.Length.Equals(1))
{
return(handler(values[0]));
}
throw new InvalidCastException();
}
public void FindIngredientInContainerTest()
{
string input = "- 1/2 cup olive oil";
Ingredient returnedIngredient;
returnedIngredient = ParseHandler.findIngredient(input, testContainer);
Assert.IsNotNull(returnedIngredient);
Assert.IsTrue(returnedIngredient.getIsOrganic());
Assert.IsFalse(returnedIngredient.getIsProduce());
Assert.AreEqual(returnedIngredient.getName(), "olive oil");
}
/// <summary>
/// Returns a <see cref="Tuple"/> with specified <paramref name="descriptor"/>
/// parsed from the <paramref name="source"/> string.
/// </summary>
/// <param name="descriptor">The descriptor of <see cref="Tuple"/> to parse.</param>
/// <param name="source">The string to parse.</param>
/// <returns>A <see cref="Tuple"/> parsed from the <paramref name="source"/> string.</returns>
/// <exception cref="System.InvalidOperationException"><paramref name="source"/> string
/// can't be parsed to a <see cref="Tuple"/> with specified <paramref name="descriptor"/>.</exception>
public static Tuple Parse(this TupleDescriptor descriptor, string source)
{
ArgumentValidator.EnsureArgumentNotNull(descriptor, "descriptor");
var target = Tuple.Create(descriptor);
var count = target.Count;
var sources = source.RevertibleSplit(Escape, Comma).ToArray();
for (int i = 0; i < count; i++)
{
ParseHandler.Get(descriptor[i]).Execute(sources, target, i);
}
return(target);
}
public void InvalidInputRecipeStringParseFail()
{
// Arrange
string input = "!@#$%^&";
IngredientType ingredType = IngredientType.Produce;
RecipeIngredient theIngredient;
// Act
theIngredient = ParseHandler.parseRecipeLine(input, testContainer);
// Assert
Assert.IsNull(theIngredient);
}
public void InvalidInputStringParseFail()
{
// Arrange
string input = "!@#$%^&";
IngredientType ingredType = IngredientType.Produce;
Ingredient theIngredient;
// Act
theIngredient = ParseHandler.parseIngredientLine(input, ingredType);
// Assert
Assert.IsNull(theIngredient);
}
public void Test_Global_Var_Decls_001()
{
string src = Resources.Global_Var_Decls_001.GetString();
var result = ParseHandler.Parse(src);
Assert.IsFalse(result.IsError);
Assert.IsNull(result.ErrorMessage);
Assert.IsNotNull(result.ParseTree);
Assert.AreEqual(2, result.ParseTree.ChildCount);
Assert.IsInstanceOfType(result.ParseTree.GetChild(0).Payload, typeof(CommonToken));
Assert.AreEqual("VAR_GLOBAL", ((CommonToken)result.ParseTree.GetChild(0).Payload).Text);
Assert.IsInstanceOfType(result.ParseTree.GetChild(1).Payload, typeof(CommonToken));
Assert.AreEqual("END_VAR", ((CommonToken)result.ParseTree.GetChild(1).Payload).Text);
}
/// <summary>
/// Loads the data.
/// </summary>
/// <param name="path">A location from which to load the data.</param>
/// <param name="handler">A method handler to which we return the data.</param>
/// <param name="asResource">If set to <c>true</c> the path is assumed to be a Resource location rather than a URI.</param>
public void LoadData(string path, ParseHandler handler, bool asResource = false)
{
m_ParseHandler = handler;
if (!string.IsNullOrEmpty(path))
{
if (asResource)
{
LoadResource(path);
}
else
{
LoadStream(path);
}
}
}
/// <summary>
/// Loads the data.
/// </summary>
/// <param name="path">A location from which to load the data.</param>
/// <param name="handler">A method handler to which we return the data.</param>
/// <param name="asResource">If set to <c>true</c> the path is assumed to be a Resource location rather than a URI.</param>
public void LoadData(string path, ParseHandler handler, bool asResource = false)
{
m_ParseHandler = handler;
if (!string.IsNullOrEmpty(path))
{
if (asResource)
{
LoadResource(path);
}
else
{
LoadStream(path);
}
}
}
static private ParseHandler <T> TryGetParser <T>(Type t)
{
MethodInfo mi;
mi = t.GetMethod("Parse", new Type[] { typeof(string) });
if (mi == null)
{
return(null);
}
else
{
ParseHandler <T> parseHandler = (ParseHandler <T>)Delegate.CreateDelegate(typeof(ParseHandler <T>), mi);
return((ParseHandler <T>)parseHandler);
}
}
static public T SafeCastFromString <T>(string source, T defaultValue)
{
if (defaultValue is string)
{
return((T)(object)source);
}
T result;
try
{
if (typeof(T).IsEnum)
{
return((T)System.Enum.Parse(typeof(T), source, true));
}
else
{
Delegate parseHandler = RetrieveHandler <T>();
TryParseHandler <T> tryParser = parseHandler as TryParseHandler <T>;
if (tryParser != null)
{
if (tryParser(source, out result) == false)
{
result = defaultValue;
}
}
else
{
ParseHandler <T> parser = parseHandler as ParseHandler <T>;
if (parser != null)
{
result = parser(source);
}
else
{
result = defaultValue;
}
}
}
}
catch
{
result = defaultValue;
}
return(result);
}
public async Task <List <BusinessLogic.Objects.Product> > GetListStockedProductsForStoreAsync(int StoreID)
{
List <BusinessLogic.Objects.Product> BLProdStockList = new List <BusinessLogic.Objects.Product>();
List <InventoryProduct> CTXInventory = await _context.InventoryProduct.AsNoTracking().Where(ip => ip.StoreNumber == StoreID).ToListAsync();
foreach (Entities.Product CTXProd in _context.Product)
{
foreach (Entities.InventoryProduct CTXInvProd in CTXInventory)
{
if (CTXInvProd.ProductTypeId == CTXProd.ProductTypeId)
{
BLProdStockList.Add(ParseHandler.ContextProductInformationToLogicProduct(CTXProd));
}
}
}
return(BLProdStockList);
}
public void ValidRecipeStringParseSuccess()
{
// Arrange
string input = "- 3/4 cup olive oil";
RecipeIngredient theIngredient;
// Act
theIngredient = ParseHandler.parseRecipeLine(input, testContainer);
// Assert
Assert.IsNotNull(theIngredient);
Assert.IsTrue(theIngredient.getIngredient().getIsOrganic());
Assert.IsFalse(theIngredient.getIngredient().getIsProduce());
Assert.AreEqual(theIngredient.getIngredient().getName(), "olive oil");
Assert.AreEqual(theIngredient.getAmount(), 0.75m);
}
public async Task <BusinessLogic.Objects.Store> GetStoreInformation(int StoreID)
{
try
{
Store CTXStore = await _context.Store.AsNoTracking().FirstAsync(s => s.StoreNumber == StoreID);
return(ParseHandler.ContextStoreToLogicStore(CTXStore));
}
catch (InvalidOperationException)
{
throw new InvalidOperationException("Unable to get a store connected to the manager's ID");
}
catch (Exception e)
{
throw new Exception("Something went wrong in getting the store's information: " + e.Message);
}
}
public async Task <BusinessLogic.Objects.Manager> GetManagerInformation(int ManagerID)
{
try
{
Manager CTXMan = await _context.Manager.AsNoTracking().FirstAsync(m => m.ManagerId == ManagerID);
return(ParseHandler.ContextManagerToLogicManager(CTXMan));
}
catch (InvalidOperationException)
{
throw new InvalidOperationException("Was unable to get a manager with that ID");
}
catch (Exception e)
{
throw new Exception("Something went wrong in getting the manager's information: " + e.Message);
}
}
public void ValidIngredientStringParseSuccessPantry()
{
// Arrange
string input = "- 1 teaspoon of salt = $0.16";
IngredientType ingredType = IngredientType.Pantry;
Ingredient theIngredient;
// Act
theIngredient = ParseHandler.parseIngredientLine(input, ingredType);
// Assert
Assert.IsNotNull(theIngredient);
Assert.IsFalse(theIngredient.getIsOrganic());
Assert.IsFalse(theIngredient.getIsProduce());
Assert.AreEqual(theIngredient.getName(), "salt");
Assert.AreEqual(theIngredient.getCost(), 0.16m);
}
public BusinessLogic.Objects.Customer GetLastCustomerWithFirstLast(string firstName, string lastName)
{
try
{
Customer CTXCust = new Customer();
//Customer CTXCustomer = await _context.Customer.Where(c => c.FirstName == firstName).LastAsync();
foreach (Customer CTXCustomer in _context.Customer.Where(c => c.FirstName == firstName && c.LastName == lastName))
{
CTXCust = CTXCustomer;
}
return(ParseHandler.ContextCustomerToLogicCustomer(CTXCust));
}
catch (InvalidOperationException e)
{
throw new Exception("Failed to get the new customer with first name: " + firstName + "\nand lastName: " + lastName + "\nException: " + e.Message);
}
}
protected void ParseFile(ParseHandler parser, string filename)
{
var reader = new StreamReader(filename);
while (!reader.EndOfStream)
{
string line = reader.ReadLine();
if (string.IsNullOrEmpty(line))
continue;
string[] tokens = line.Split(omitchars, StringSplitOptions.RemoveEmptyEntries);
if (tokens == null || tokens[0].StartsWith("#"))
continue;
parser(line, tokens);
}
}
public HttpDataQuery(HttpRequest request)
{
Cmd = request.Form["act"];
Queries = new Node();
Queries["cmd"] = new Node(Cmd, NodeType.String);
Queries["curtstyle"] = new Node(NodeType.String);
Queries["fields"] = new Node("name", NodeType.Object);
//select [pagesize] [fields] from [tables] [wheres] [orders]
//select [pagesize] [fields] from [tables] where [pk] not in select [excludes] from [tables] [wheres] [orders]
Queries.AddChild("select", NodeType.Object);
Queries["select"]["fields"] = new Node("#name", NodeType.Array);
Queries["select"]["tables"] = new Node("#name", NodeType.Array);
Queries["select"]["wheres"] = new Node("#list", NodeType.Object);
Queries["select"]["orders"] = new Node("#list", NodeType.Object);
Queries["select"]["pagesize"] = new Node("#num", NodeType.Empty);
Queries["select"]["pageskip"] = new Node("#num", NodeType.Empty);
Queries["select"]["curtpage"] = new Node("#num", NodeType.Empty);
Queries["select"]["pk"] = new Node("#name", NodeType.Object);
Form = request.Form;
Qstyle = Form["qstyle"];
Queries.SetValue(Qstyle, NodeType.String, "curtstyle");
if (string.IsNullOrEmpty(Qstyle))
{
Qstyle = "select";
}
if (string.IsNullOrEmpty(Cmd))
{
Cmd = "normal";
}
Node Root = Queries["select"];
OnParse = ParseTypes;
EnumNames(null);
OnParse = ParseNames;
EnumNames(Root);
Sql = MakeSql();
}
public IniPropertyDescription(string name, PropertyInfo property, Type itemType, ParseHandler parseHandler, int minOccurrences = 0, int maxOccurrences = 1)
{
_name = name;
_property = property;
TheParseHandler = parseHandler;
_minOccurrences = minOccurrences;
_maxOccurrences = maxOccurrences;
_itemType = itemType;
}
