private Dictionary <string, object> GetData(Article?article, bool isTwoColumn, bool isWide)
{
if (article is null)
{
return(new Dictionary <string, object>());
}
var(width, height, wrapperWidth) = GetImageSize(article.Image, isTwoColumn, isWide);
return(new Dictionary <string, object>
{
{ "id", article.Id },
{ "headline", article.Headline },
{ "description", RenderMarkdown(article.Description) },
{ "imageCaption", article.Excerpt },
{
"image", new Dictionary <string, object>
{
{ "url", article.Image?.Url ?? string.Empty },
{ "width", width },
{ "height", height },
{ "wrapperWidth", wrapperWidth }
}
},
{
"category", new Dictionary <string, object>
{
{ "slug", article.Category?.Slug ?? string.Empty },
{ "name", article.Category?.Name ?? string.Empty },
{ "color", article.Category?.Color ?? string.Empty },
{ "image", article.Category?.Image?.Url ?? string.Empty }
}
}
});
}
private Dictionary <string, object> GetData(Article?article)
{
if (article is null)
{
return(new Dictionary <string, object>());
}
return(new Dictionary <string, object>
{
{ "id", article.Id },
{ "headline", article.Headline },
{ "description", article.Description },
{
"image", new Dictionary <string, object>
{
{ "url", article.Image?.Url ?? string.Empty }
}
},
{
"category", new Dictionary <string, object>
{
{ "slug", article.Category?.Slug ?? string.Empty },
{ "name", article.Category?.Name ?? string.Empty },
{ "color", article.Category?.Color ?? string.Empty },
{ "image", article.Category?.Image?.Url ?? string.Empty }
}
}
});
}
/// <summary>Parses a/an, the, many/multiple/several. Will eat "the many" as "many".</summary>
static Article?ParseArticle(string[] words)
{
Article?found = null;
string word = words[index];
index++;
if (stringnums.IndefiniteArticles.Contains(word))
{
found = Article.a;
}
if (stringnums.DefiniteArticles.Contains(word))
{
found = Article.the;
}
if (stringnums.ListDeterminers.Contains(word))
{
found = Article.many;
}
if (found != null)
{
var found2nd = ParseArticle(words);
return(found2nd ?? found); // eat "the many", returning "many"; otherwise just return whatever one word we found
}
index--;
return(null);
}
private IEnumerable <Article?> Parse()
{
MainPageScenarios.OpenFreshSection();
for (var i = 0; i < _applicationConfiguration.ContentAmount; i++)
{
Log.Debug($"Began parsing article {i + 1}");
Article?article = null;
try
{
string title = MainPageScenarios.GetTitle(i);
article = new Article(title)
{
Image = MainPageScenarios.GetImage(i),
Video = MainPageScenarios.GetVideo(i)
};
Log.Debug($"Article {i + 1} (\"{article}\") has been parsed");
}
catch (ControlDoesntExistException exception)
{
var logBuilder = new StringBuilder();
logBuilder.AppendLine($"Article {i + 1} hasn't been parsed")
.Append(exception);
Log.Warning(logBuilder.ToString());
}
yield return(article);
}
}
/// <summary>A somewhat high-level function to parse (only) a single indeterminate noun phrase like "a numeric entry", "a number",
/// "a car", "a vertical percentage", "several cars", "anything", "the manager" (if the NP is the subject of its
/// sentence), "many gadgets" (when gadget itself hasn't been established yet), or a number of specifically invalid
/// combinations, that describes a typed parameter in the definition of a multimethod's signature.
/// Will soon need ability to parse -ing phrases and sub-predicates as in "To learn (repairing a car with a tool)".
/// Uses ParseArticle, ParseNewIdentifier, ParseAdjectiveType, Parse enum, ParseAnyType, and multiple NameOfType.
/// Finally calls CreateParameterObject after all but the worst parses.
/// </summary>
static parameter ParseNounPhraseForParameter(string[] words, bool isSubject = false)
{
StandardType?type = null;
string ident = "";
int savedIndex = index;
bool identIsAdjectiveTypeIsNoun = false;
// usually if the type is the noun, there is no adjective: "the task"
// and usually if both adj & noun are present, the type is the adjective: "the numeric virtue"
// this is for constructions like "the horizontal percent, the vertical percent"
// step 1: try parsing "something", "an adjective-type noun" "nountype", etc., or as a last resort, just a new identifier
Article? mode = ParseArticle(words) ?? ((isQuestion && isSubject) ? Article.a : (Article?)null);
OtherParameterTypes? opt = Parse <OtherParameterTypes>(words[index]);
StandardTypeAdjective?adjtype = ParseAdjectiveType(words);
if (adjtype != null)
{
ident = ParseNewIdentifier(words, ref type);
if (type != null && type != (StandardType)adjtype)
{
Console.WriteLine("ERROR: I'm unsure whether '{0} {1}' is a {1} nicknamed {0} or is something {0} nicknamed {1}.", adjtype, type);
method_being_constructed.problems++;
return(null);
}
type = (StandardType)adjtype;
if (ident == "")
{
Console.WriteLine("ERROR: must provide a name after the adjective '{0}' or use its noun form instead, '{1}'.", adjtype, (StandardType)adjtype);
method_being_constructed.problems++;
return(null);
}
}
else if (opt != null)
{
type = (StandardType)opt;
}
else
{
fiveforms ing = PresentParticiple(words[index]);
if (ing != null)
{
return(CreateFunctionParameterObject(words, ing, isSubject));
}
type = ParseAnyType(words);
ident = (type == null) ? "" : NameOfType(type.Value);
}
if (ident == "" && type == null /*&& isSubject*/) // then we have no type info whatsoever. Just get a new ident
{
ident = ParseNewIdentifier(words, ref type);
identIsAdjectiveTypeIsNoun = (type != null);
}
if (type == null && mode == null)
{ // if we know nothing, abort
index = savedIndex;
return(null);
}
return(CreateParameterObject(words, mode, type, adjtype, ident, identIsAdjectiveTypeIsNoun, isSubject));
}
/// <summary>
/// Initializes a new instance of <see cref="WikiLink"/>.
/// </summary>
/// <param name="article">
/// The linked article (if any).
/// </param>
/// <param name="missing">
/// Whether this is a link to a missing page.
/// </param>
/// <param name="isCategory">
/// Whether this is a link to a category.
/// </param>
/// <param name="isNamespaceEscaped">
/// Whether a leading ':' precedes the namespace.
/// </param>
/// <param name="isTalk">
/// Whether this is a link to a discussion page.
/// </param>
/// <param name="title">
/// The title for the linked article.
/// </param>
/// <param name="wikiNamespace">
/// The namespace for the linked article.
/// </param>
public WikiLink(
Article?article,
bool missing,
bool isCategory,
bool isNamespaceEscaped,
bool isTalk,
string title,
string wikiNamespace)
{
Article = article;
Missing = missing;
IsCategory = isCategory;
IsNamespaceEscaped = isNamespaceEscaped;
IsTalk = isTalk;
Title = title;
WikiNamespace = wikiNamespace;
}
private (Article?, List <Article>) PickArticle(List <Article> articles, Func <Article, bool> selector)
{
var remainingArticles = new List <Article>();
Article?result = null;
foreach (var article in articles)
{
if (result == null && selector(article))
{
result = article;
}
else
{
remainingArticles.Add(article);
}
}
return(result, remainingArticles);
}
private static Article GetArticle(string markdown)
{
if (_Article is null)
{
_Article = Article.NewAsync(
_Options,
_DataStore,
Title,
Editor,
markdown)
.GetAwaiter()
.GetResult();
}
else
{
_Article.ReviseAsync(_Options, _DataStore, Editor, markdown: markdown).GetAwaiter().GetResult();
}
return(_Article);
}
private static Article GetNestedArticle(string markdown, string?wikiNamespace = null)
{
if (_NestedArticle is null)
{
_NestedArticle = Article.NewAsync(
_Options,
_DataStore,
NestedTitle,
Editor,
markdown,
wikiNamespace ?? _Options.TransclusionNamespace)
.GetAwaiter()
.GetResult();
}
else
{
_NestedArticle.ReviseAsync(_Options, _DataStore, Editor, markdown: markdown).GetAwaiter().GetResult();
}
return(_NestedArticle);
}
/// <summary>When defining a parameter of a new function's signature, and once parsing of that parameter is done, this converts
/// the information into a parameter object. Uses CreateListParameterObject since that is a tome in itself.</summary>
static parameter CreateParameterObject(string[] words, Article?mode, StandardType?type, StandardTypeAdjective?adjtype, string ident, bool identIsAdjectiveTypeIsNoun = false, bool isSubject = false)
{
// something/nothing/anything aren't preceded by an article. Treat as "a thing"
if (type.HasValue && type <= StandardType.something)
{
Console.WriteLine(" declaring a parameter which {0}", type == StandardType.nothing ? "must be nothing" : type == StandardType.anything ? "could be anything" : "mustn't be nothing");
return(new parameter("", type.Value.ToString(), Article.a, type.Value, identIsAdjectiveTypeIsNoun));
}
switch (mode)
{
case Article.the:
if (type.HasValue)
{
if (adjtype == null)
{
Console.WriteLine("ERROR: we say 'the {0}' to use it later in the sentence. Here we should say 'a {0}'.", NameOfType(type.Value));
}
else
{
Console.WriteLine("ERROR: we say 'the {0}' to use it later in the sentence. Here we should say 'a {0} {1}'.", adjtype, ident == "" ? "name-of-it" : ident);
}
method_being_constructed.problems++;
return(null);
}
if (isSubject || isQuestion)
{
just_declared_new_type = isSubject; // and a global instance, as well
return(new parameter("", ident, mode ?? Article.the, type ?? StandardType.number, identIsAdjectiveTypeIsNoun));
}
Console.WriteLine("ERROR: we should use 'a' not 'the' in this part of the sentence.");
method_being_constructed.problems++;
return(null);
case Article.many:
return(CreateListParameterObject(ref type, ident, identIsAdjectiveTypeIsNoun));
case Article.a:
if (type.HasValue) // also, should we disallow it when the ident is also a type? "numeric car"
{
Console.WriteLine(" declaring a parameter of type {0} called '{1}'", NameOfType(type.Value), ident);
InheritedType it = InheritanceTree.Find(item => item.name == ident);
if (it != null && it.typeid != type.Value)
{
Console.WriteLine(" WARNING: '{0}' is declared elsewhere as a '{1}', not a '{2}'", it.name, NameOfType(it.typeid), NameOfType(type.Value));
}
}
else if (isQuestion && incarnations == TheVerbIs)
{
for (IdentEndsAt = index; IdentEndsAt < words.Length && words[IdentEndsAt] != "?"; IdentEndsAt++)
{
;
}
if (IdentEndsAt >= words.Length)
{
Console.WriteLine(" ERROR: I thought #{0} was a question because it began with '{1}', but I couldn't find a question mark afterward.", method_being_constructed.prompt, method_being_constructed.question);
method_being_constructed.problems++;
return(null);
}
Console.WriteLine(" defining a {0} by Q&A.", ident);
ident = ParseNewIdentifier(words, ref type);
}
else if (!isSubject)
{
if (ident == "") // then we have no type info whatsoever. Just get a new ident
{
ident = ParseNewIdentifier(words, ref type);
}
Console.WriteLine(" TODO: is '{0}' textual? Numeric? Or something more complex?", ident);
method_being_constructed.todo++;
}
// defining a new type
else if (InheritanceTree.Find(item => item.name == ident) != null)
{
Console.WriteLine(" ERROR: re-defining type '{0}'.", ident);
method_being_constructed.problems++;
//return null; // let it parse for now
return(new parameter("", ident, mode ?? Article.a, type ?? (StandardType)0, identIsAdjectiveTypeIsNoun));
}
else
{
// object until proven otherwise. heck, it may not even be a type, it might be an instance or variable.
var newType = CreateNewType(ident);
Console.WriteLine(" assuming '{0}' is a new type", newType.name, newType.typeid);
}
break;
case null:
if (type == null)
{
return(null);
}
if (ident == null)
{
Console.WriteLine(" plural(?) parameter of type {0}", type);
}
else
{
Console.WriteLine(" plural(?) parameter of type {1} called the {0}", ident, NameOfType(type.Value));
}
break;
}
return(new parameter("", ident, mode ?? Article.a, type ?? (StandardType)0, identIsAdjectiveTypeIsNoun));
}
private void AddArticleToData(string key, Dictionary <string, object> data, Article?article)
{
data.Add(key, GetData(article));
}
/// <summary>Called from ParseAnInvocation2.
/// Tries to match the current words in the source to exactly one in-scope thing which satisfies the given parameter's type.
/// On success returns the Instance (literal value, variable which holds the value, etc.)
/// Uses IsNameOfTypeWhich, ParseRelativeInvocation, ParseNumberOrdinalPercent, MatchToNamedStorageLocation.</summary>
static instance ParseInvokedNoun(List <string> words, parameter satisfyMe, bool allowUnboundVariables = false)
{
if (index >= words.Count)
{
return(null);
}
int savedIndex = index;
while (words[index] == "the")
{
index++;
}
theTypeWhich theTypeWhich = null;
invocation inv = null;
long? number = null;
Article? art = null;
if (words[index].StartsWith("__litstring"))
{
return (IsA(StandardType.text, satisfyMe.type)) ? null : new instance()
{
var = satisfyMe, literalString = Say(words[index++]), type = StandardType.text, toAccess = Indirectedness.literal
}
}
;
if ((theTypeWhich = IsNameOfTypeWhich(words)) != null && ((inv = ParseARelativeInvocation(theTypeWhich, words)) != null))
{
return new instance()
{
var = satisfyMe, type = theTypeWhich.type.typeid, inner = inv, toAccess = Indirectedness.nested_invocation
}
}
;
if (satisfyMe.isAggregate && words[index].EndsWith("ing") && (inv = ParseAGerundInvocation(satisfyMe, words)) != null)
{
return new instance()
{
var = satisfyMe, type = satisfyMe.type, inner = inv, toAccess = Indirectedness.nested_invocation
}
}
;
if ((number = ParseNumberOrdinalPercent(words)) != null)
{
return (!IsA(numtype.AsStandardType(), satisfyMe.type)) ? null : new instance()
{
var = satisfyMe, literalValue = number.Value, type = numtype.AsStandardType(), toAccess = Indirectedness.literal
}
}
;
if (allowUnboundVariables && (art = ParseArticle(words.ToArray())) != null)
{
index = savedIndex; // back up over the article(s) for the following function to eat
parameter unbound = ParseNounPhraseForParameter(words.ToArray(), false);
if (unbound == null)
{
return(null);
}
return(new instance()
{
var = unbound, toAccess = Indirectedness.unbound
});
}
return(MatchToNamedStackLocation(words));
}
public void DeleteArticle(string articleTitle)
{
Article?toDelete = articles.SingleOrDefault(a => a.Title.Equals(articleTitle));
if (toDelete is {})
public async Task <ReceiptModel> Handle(ImportReceipt request, CancellationToken cancellationToken)
{
Store store = await dbContext.Stores
.Include(x => x.Products).ThenInclude(x => x.Article)
.SingleOrDefaultAsync(x => x.Uuid == request.Model.StoreId, cancellationToken)
?? throw new NotFoundException(nameof(request.Model.StoreId));
if (store.AccountId != appContext.Account !.Id)
{
throw new ForbiddenException();
}
Dictionary <long, Article> articles = await dbContext.Articles
.Where(x => x.AccountId == appContext.Account.Id && x.Gtin.HasValue)
.ToDictionaryAsync(x => x.Gtin !.Value, x => x, cancellationToken);
Dictionary <string, Department> departments = await dbContext.Departments
.Where(x => x.StoreId == store.Id && x.Number != null)
.ToDictionaryAsync(x => x.Number !, x => x, cancellationToken);
Dictionary <int, Product> productsByArticle = store.Products
.ToDictionary(x => x.ArticleId, x => x);
Dictionary <string, Product> productsBySku = store.Products
.Where(x => x.Sku != null)
.ToDictionary(x => x.Sku !, x => x);
DateTimeOffset now = dateTimeOffset.Now;
var receipt = new Receipt
{
CreatedAt = now,
IssuedAt = request.Model.IssuedAt ?? now,
Number = request.Model.Number?.CleanTrim(),
Store = store,
StoreId = store.Id,
UpdatedAt = now,
Uuid = guid.NewGuid()
};
var gst = new Tax
{
Code = "GST",
Rate = taxOptions.Gst
};
receipt.Taxes.Add(gst);
var qst = new Tax
{
Code = "QST",
Rate = taxOptions.Qst
};
receipt.Taxes.Add(qst);
IEnumerable <LineInfo> lines = parser.Execute(request.Model.Lines);
foreach (LineInfo line in lines)
{
Article? article = null;
Department?department = null;
Product? product = null;
if (line.Department != null)
{
if (!departments.TryGetValue(line.Department.Number, out department))
{
department = new Department
{
CreatedAt = now,
Name = line.Department.Name,
Number = line.Department.Number,
Store = store,
StoreId = store.Id,
UpdatedAt = now,
Uuid = guid.NewGuid()
};
departments.Add(department.Number, department);
dbContext.Departments.Add(department);
await dbContext.SaveChangesAsync(cancellationToken);
}
}
string?sku = null;
long? gtin = ParseGtin(line.Id);
if (gtin.HasValue)
{
if (articles.TryGetValue(gtin.Value, out article))
{
productsByArticle.TryGetValue(article.Id, out product);
}
}
else
{
sku = line.Id;
productsBySku.TryGetValue(sku, out product);
}
if (product == null)
{
if (article == null)
{
article = new Article
{
AccountId = appContext.Account.Id,
CreatedAt = now,
Gtin = gtin,
Name = line.ToString(),
UpdatedAt = now,
Uuid = guid.NewGuid()
};
dbContext.Articles.Add(article);
if (gtin.HasValue)
{
articles.Add(gtin.Value, article);
}
}
product = new Product
{
CreatedAt = now,
Department = department,
DepartmentId = department?.Id,
Flags = line.Flags,
Label = line.Label,
Sku = sku,
Store = store,
StoreId = store.Id,
UnitPrice = line.UnitPrice,
UpdatedAt = now,
Uuid = guid.NewGuid()
};
article.Products.Add(product);
if (sku != null)
{
productsBySku.Add(sku, product);
}
await dbContext.SaveChangesAsync(cancellationToken);
productsByArticle.Add(article.Id, product);
}
receipt.Items.Add(new Item
{
Price = line.Price,
Product = product,
ProductId = product.Id,
Quantity = line.Quantity ?? 1,
UnitPrice = line.UnitPrice ?? line.Price,
Uuid = guid.NewGuid()
});
receipt.SubTotal += line.Price;
if (product.Flags?.Any(x => x.Contains("F")) == true)
{
gst.TaxableAmount += line.Price;
}
if (product.Flags?.Any(x => x.Contains("P")) == true)
{
qst.TaxableAmount += line.Price;
}
}
receipt.Total = receipt.SubTotal;
foreach (Tax tax in receipt.Taxes)
{
tax.Amount = tax.TaxableAmount * (decimal)tax.Rate;
receipt.Total += tax.Amount;
}
dbContext.Receipts.Add(receipt);
await dbContext.SaveChangesAsync(cancellationToken);
return(mapper.Map <ReceiptModel>(receipt));
}