public async Task SendMealPlanToSubscriber(string subscriberEmail)
{
_logger.LogInfo($"--------------------------------------------------------------");
var lunchMenu = _factory.GenerateLunchesMenu();
var dessertMenu = _factory.GenerateDessertsMenu();
var shoppingList = _factory.GenerateShoppingList();
lunchMenu.PrintDescription();
_logger.LogInfo($"== 🍜 Compiling Lunches Menu for Subscriber: {subscriberEmail} ==", ConsoleColor.Cyan);
lunchMenu.PrintMenu();
dessertMenu.PrintDescription();
_logger.LogInfo($"== 🍜 Compiling Desserts Menu for Subscriber: {subscriberEmail} ==", ConsoleColor.Cyan);
dessertMenu.PrintMenu();
var ingredients = shoppingList.MakeShoppingList();
var emailBody = string.Join(", ", ingredients);
var message = new EmailMessage(subscriberEmail, emailBody);
_logger.LogInfo("== ✈️ Sending Subscriber Email ==", ConsoleColor.Cyan);
await _emailer.SendMessage(message);
_logger.LogInfo($"--------------------------------------------------------------", ConsoleColor.Cyan);
}
public override KombuchaSale Handle(KombuchaSale request)
{
if (request.SaleType == SaleType.InHouse)
{
_logger.LogInfo("Printing receipt for in-house order.", ConsoleColor.Green);
return(base.Handle(request));
}
if (request.SaleType != SaleType.Online)
{
return(base.Handle(request));
}
_logger.LogInfo("Emailing receipt for online order.", ConsoleColor.Green);
var emailReceipt = new EmailMessage("*****@*****.**", "Here's your receipt.");
if (request.SpecialMessages != null && request.SpecialMessages.Any())
{
foreach (var message in request.SpecialMessages)
{
emailReceipt.Content += $"| {message}";
}
}
var emailTask = _emailer.SendMessage(emailReceipt);
emailTask.Wait();
return(base.Handle(request));
}
private async Task RunImageProcessingAppAsync(IApplicationLogger logger)
{
var processStartInfo = new ProcessStartInfo("cmd.exe", "/c startpyapp.bat");
processStartInfo.CreateNoWindow = true;
processStartInfo.UseShellExecute = false;
processStartInfo.RedirectStandardError = true;
processStartInfo.RedirectStandardOutput = true;
var process = Process.Start(processStartInfo);
if (process == null)
{
throw new Exception("Process cannot be null");
}
process.OutputDataReceived += (sender, e) =>
logger.LogInfo("RunImageProcessingApp - output>>" + e.Data);
process.BeginOutputReadLine();
process.ErrorDataReceived += (sender, e) =>
logger.LogInfo("RunImageProcessingApp - error>>" + e.Data);
process.BeginErrorReadLine();
await Task.Delay(TimeSpan.FromSeconds(10));
}
/// <summary>
/// Here the Florist Co-Op wants to be emailed when we run the Sales Report
/// The FloristDataProcessor doesn't know anything other than how to generate
/// the data it already works with, and a method enabling it to be "visited."
/// </summary>
/// <param name="processor"></param>
/// <returns></returns>
public SalesReport Visit(FloristDataProcessor processor)
{
Console.ForegroundColor = ConsoleColor.Magenta;
_logger.LogInfo("Visiting Florist for Sales Report");
var sales = processor.GetDailyOrderAmounts();
Console.ResetColor();
return(new SalesReport(_logger, DateTime.UtcNow, sales.Sum()));
}
public void Add(string doughnut)
{
// We persist the current state before updating the cart with a new doughnut
var memento = _cart.Save();
_caretaker.SafekeepState(memento);
_cart.AddDoughnut(doughnut);
_logger.LogInfo($"(Cart Client) Added doughnut and persisted this event to memory: [{doughnut}]");
}
// The Context delegates some work to the Strategy object instead of
// implementing multiple versions of the algorithm on its own.
public async Task PublishMenu()
{
_logger.LogInfo("Generating the Menu.");
var currentMenu = await _strategy.GenerateMenu();
foreach (var item in currentMenu.MenuItems)
{
_logger.LogInfo(
$"- {item.Name} | {item.Description} | {item.Price}", ConsoleColor.Cyan);
}
}
public void OnPurchase(int points)
{
_state.OnPurchase(points);
_logger.LogInfo($"You earned {points} points", ConsoleColor.Green);
_logger.LogInfo($"Current Points: {PointsBalance}", ConsoleColor.Green);
_logger.LogInfo($"Rewards Status: {RewardsTier.GetType().Name}", ConsoleColor.Green);
_logger.LogInfo($"-------------------------------");
}
public MarketResearchReport Visit(FloristDataProcessor processor)
{
var customerProfiles = processor.GetMonthlyCustomerProfiles();
var customerAges = customerProfiles.Select(customer => customer.Age).ToList();
var averageAge = (decimal)Math.Round(customerAges.Average(), 2);
var youngestAge = customerAges.Min();
var oldestAge = customerAges.Max();
_logger.LogInfo("Visiting Florist for Generating Market Report", ConsoleColor.Green);
var report = new MarketResearchReport(_logger);
report.SetData(customerProfiles.Count, averageAge, oldestAge, youngestAge);
return(report);
}
public async Task SaveClustersAsync()
{
var trainSamples = await _samplesService.GetTrainPhotosAsync();
var clusters = await BuildClustersAsync(_numberOfClusters, trainSamples);
await _clusterSamplePhotoRepository.DeleteAsync(x => true);
await _clusterRepository.DeleteAsync(x => true);
foreach (var cluster in clusters)
{
await _clusterRepository.CreateAsync(cluster);
}
_logger.LogInfo("Old clusters removed and new clusters added.");
}
public void SignUpUser()
{
if (_onStart != null)
{
_logger.LogInfo("Running pre-process hook.", ConsoleColor.DarkMagenta);
_onStart.Execute();
}
_logger.LogInfo("New user is signed up.", ConsoleColor.DarkMagenta);
if (_onFinish == null)
{
return;
}
_logger.LogInfo("Running post-process hook.", ConsoleColor.DarkMagenta);
_onFinish.Execute();
}
public void Execute()
{
var payload = $"Hi, {_name}! Welcome to the neighborhood compost group!";
var email = new EmailMessage(_emailAddress, payload);
_logger.LogInfo($"Sending new customer {_name} a welcome email.", ConsoleColor.Blue);
_emailer.SendMessage(email);
}
public void Print()
{
foreach (var recipe in _recipes)
{
recipe.PrintSteps();
_logger.LogInfo("-------------------------------", ConsoleColor.DarkMagenta);
}
}
public void QueueVehicleForDelivery()
{
var vehicle = RegisterVehicle();
var vehiclePayload = JsonConvert.SerializeObject(vehicle);
var queueMessage = new QueueMessage(vehiclePayload);
_deliveryQueue.Add(queueMessage);
_logger.LogInfo($"Queued up vehicle of type {vehicle.GetType()} for food delivery.");
}
// The client code can run visitor operations over any set of elements
// without figuring out their concrete classes. The accept operation
// directs a call to the appropriate operation in the visitor object.
public void RunReports(List <IVisitable <Report> > visitables, IVisitor <Report> visitor)
{
_logger.LogInfo($"Running Report on {visitables.Count} Data Providers", ConsoleColor.Cyan);
foreach (var component in visitables)
{
var report = component.Accept(visitor);
report?.Print();
}
}
public override KombuchaSale Handle(KombuchaSale request)
{
if (request.CustomerType == CustomerType.RewardsMember)
{
_logger.LogInfo("Adding rewards point for purchase!", ConsoleColor.Green);
return(base.Handle(request));
}
if (request.CustomerType != CustomerType.RewardsMember)
{
_logger.LogInfo("Adding advertisement to request.", ConsoleColor.Green);
request.SpecialMessages.Add("Have you heard about our Rewards Program?");
return(base.Handle(request));
}
Console.ResetColor();
return(base.Handle(request));
}
public void TranslateBarcode()
{
_logger.LogInfo($"Translating scanned barcode: {_context.BarcodeExpression}", ConsoleColor.Green);
var chars = _context.BarcodeExpression.ToCharArray();
var expressions = new List <IExpression>();
// This is usually represented as an Abstract Syntax Tree.
// For the purposes of this example, we have a simple grammar
// and sentences are represented as lists (i.e. only terminal nodes).
foreach (var symbol in chars)
{
_logger.LogInfo($"Interpreting symbol: {symbol}", ConsoleColor.DarkGray);
// If our symbol matches Terminal Expression Symbols, add it to our Expressions
if (_context.TerminalExpressionSymbols.Contains(symbol))
{
// If it's a number, create a quantity expression
if (int.TryParse(symbol.ToString(), out int _))
{
expressions.Add(new QuantityExpression(symbol));
}
// Otherwise, create an origin expression
expressions.Add(new OriginExpression());
}
}
foreach (var expression in expressions)
{
expression.Evaluate(_context);
}
var output = _context.TranslatedOutput;
if (!string.IsNullOrWhiteSpace(output))
{
_logger.LogInfo($"This translates to: {_context.TranslatedOutput}", ConsoleColor.Green);
}
else
{
_logger.LogInfo($"Hmm... That looks like an invalid barcode.", ConsoleColor.Red);
}
}
public async Task <string> MakeHttpRequestForRecipe(string recipe)
{
_logger.LogInfo($"Making HTTP request returning XML for: {recipe}", ConsoleColor.Magenta);
await Task.Delay(2000);
var databaseResponse = _database[recipe];
var xmlSerializer = new XmlSerializer(databaseResponse.GetType());
await using var stringWriter = new StringWriter();
await using var writer = XmlWriter.Create(stringWriter, new XmlWriterSettings { Async = true });
xmlSerializer.Serialize(writer, databaseResponse);
return(stringWriter.ToString());
}
public override KombuchaSale Handle(KombuchaSale request)
{
if (request.SaleType == SaleType.InHouse)
{
return(base.Handle(request));
}
if (request.SaleType == SaleType.Online)
{
_logger.LogInfo("Printing shipping label for online order.", ConsoleColor.Green);
return(base.Handle(request));
}
return(base.Handle(request));
}
public override KombuchaSale Handle(KombuchaSale request)
{
if (request.SaleType == SaleType.InHouse)
{
return(base.Handle(request));
}
if (request.SaleType != SaleType.Online)
{
return(base.Handle(request));
}
_logger.LogInfo("Cartonizing online order.", ConsoleColor.Green);
return(base.Handle(request));
}
public void KickOffProduceReport()
{
_finance.CalculateMonthTotalRevenue();
_inventory.ProcessCurrentInventoryReport();
var vendors = _vendors.GetVendorsForDepartment("produce");
foreach (var vendor in vendors)
{
_vendors.NotifyVendorOfCurrentStock(vendor);
_finance.CalculateMonthTotalRevenueForVendor(vendor);
}
var report = new ReportGenerator.Report {
Title = "Daily Produce Report",
Description = "The daily produce report details..."
};
var reportLog = _report.GenerateReportLog(report);
_logger.LogInfo(reportLog);
}
public IMenu GenerateDessertsMenu()
{
_logger.LogInfo("== 🥭 Generating a Vegetarian Dessert Menu... ==", ConsoleColor.Green);
return(new VegetarianDessertMenu());
}
private void PrintEquipmentHeading()
{
Console.ForegroundColor = ConsoleColor.Blue;
_logger.LogInfo("~ Required Equipment ~");
Console.ResetColor();
}
public void Add(QueueMessage item)
{
Thread.Sleep(250);
_logger.LogInfo($"Added to queue: {item.Content}", ConsoleColor.Magenta);
}
public void AddDoughnut(string doughnut)
{
_state += $"_{doughnut}";
_logger.LogInfo("(Cart) Added a doughnut to the cart", ConsoleColor.DarkGray);
Save();
}
public void Execute()
{
_logger.LogInfo("Adding User Address to Compost AWS Queue", ConsoleColor.Blue);
_queue.Add(new QueueMessage(_address));
}
private async Task LogMessageAsync(string type, string correlationId, string requestInfo, string body)
{
await Task.Run(() => _logger.LogInfo($"{correlationId} - {requestInfo} - API - {type}: \r\n{body}"));
}
public async Task SendMessage(EmailMessage message)
{
await Task.Delay(1000);
_logger.LogInfo($"Sent email to: {message.To} with Message: {message.Content}", ConsoleColor.Cyan);
}
public async Task SavePurchaseOrderToDatabase(PurchaseOrder purchaseOrder)
{
_logger.LogInfo($"Saving P.O. ({purchaseOrder.Id}) to database");
await _database.Connect();
await _database.WriteData(purchaseOrder.Id, JsonConvert.SerializeObject(purchaseOrder));
await _database.Disconnect();
}
public IChairIcon CloneChair()
{
_logger.LogInfo("Creating a clone of a Chair.", ConsoleColor.Cyan);
return((IChairIcon)_chair.DeepClone());
}
public IMenu GenerateDessertsMenu()
{
_logger.LogInfo("== 🍨 Generating a Keto Dessert Menu... ==");
return(new KetoDessertMenu());
}
