public void CreateReceipt_CheckProperties_ShouldReturnCorrectValueProperties()
{
// Assemble
_cart.Products[0].Discount = Discount.Bonus;
_cart.Products[0].Amount = 3;
// Assign
var expectedMessage = "Bedankt dat u bij de Boni bent geweest!";
var expectedProductName = "Kaas";
var expectedOriginalPrice = 4.99M;
var expectedDiscount = Discount.Bonus;
var expectedDiscountPrice = 3.99M;
var expectedTotal = 11.98M;
// Act
var receipt = ReceiptService.CreateReceipt(_cart);
// Assert
Assert.Multiple(() =>
{
Assert.AreEqual(expectedMessage, receipt.Message);
Assert.AreEqual(expectedProductName, receipt.BoughtProducts[0].ProductName);
Assert.AreEqual(expectedOriginalPrice, receipt.BoughtProducts[0].ProductPrice);
Assert.AreEqual(expectedDiscount, receipt.BoughtProducts[0].Discount);
Assert.AreEqual(expectedDiscountPrice, receipt.BoughtProducts[0].ProductPriceWithDiscount);
Assert.AreEqual(expectedTotal, receipt.BoughtProducts[0].Total);
});
}
public ResourceData <string> EnterVehicle(long entryDate, Vehicle vehicle)
{
var resourceData = new ResourceData <string>
{
_status = (int)StatusData.LOADING
};
try
{
resourceData._status = (int)StatusData.SUCCESS;
resourceData._message = ReceiptService.EnterVehicle(entryDate, vehicle);
}
catch (Exception e)
{
resourceData._status = (int)StatusData.ERROR;
resourceData._message = e.GetType() switch
{
Type t when typeof(RealmDuplicatePrimaryKeyValueException).IsInstanceOfType(t) => Context.GetString(Resource.String.vehicle_already_in_the_parking_lot),
Type t when typeof(MaximunCantVehicleException).IsInstanceOfType(t) => Context.GetString(Resource.String.there_is_no_space_to_store_the_vehicle),
Type t when typeof(CanNotEnterVehicleException).IsInstanceOfType(t) => Context.GetString(Resource.String.you_cannot_enter_the_vehicle_since_it_is_not_sunday_or_monday),
_ => Context.GetString(Resource.String.something_unexpected_happened)
};
}
return(resourceData);
}
public void GetReceiptPancake()
{
var service = new ReceiptService(new FakeFridgeItemRepository(), new FakeReceiptRepository());
var result = service.GetReceipt(PancakeReceipt);
Assert.AreEqual(result.Name, PancakeReceipt);
}
public StartWindowViewModel()
{
OpenTableNumberCommand = new CustomCommand(OpenTableNumber, CanOpenTableNumber);
ShowMenuCategoriesCommand = new CustomCommand(ShowMenuCategories, CanShowMenuCategories);
PrintReceiptCommand = new CustomCommand(PrintReceipt, CanPrintReceipt);
OpenOptionsStartersCommand = new CustomCommand(OpenOptionsStarters, CanOptionsOpenStarters);
OpenOptionsMainsCommand = new CustomCommand(OpenOptionsMains, CanOpenOptionsMains);
OpenOptionsDessertsCommand = new CustomCommand(OpenOptionsDesserts, CanOpenOptionsDesserts);
OpenOptionsDrinksCommand = new CustomCommand(OpenOptionsDrinks, CanOpenOptionsDrinks);
receiptService = new ReceiptService();
getMoneyService = new GetMoneyService();
options = new Options();
dataHandling = new DataHandling();
TableList = StartUp(@"C:\Users\Public\Documents\NumberOfTables.txt");
IsAddOrderButtonEnabled = "False";
IsPrintButtonEnabled = "False";
SendNumberOfTablesMessenger.Default.Register <int>(this, OnReceiveTableNumber);
RequestTableNumberCloseMessenger.Default.Register <Object>(this, OnReceiveTableNumberClose);
OpenMenuItemsViewMessenger.Default.Register <Object>(this, OnReceiveOpenMenuItems);
AddSelectedItemMessenger.Default.Register <MenuItemModel>(this, OnReceiveMenuItem);
ReturnToMenuCategoriesMessenger.Default.Register <Object>(this, OnReceiveReturnToCategories);
RequestMenuItemsCloseMessenger.Default.Register <Object>(this, OnReceiveMenuItemsClose);
RequestGetMoneyCloseMessenger.Default.Register <Object>(this, OnReceiveGetMoneyClose);
RequestReceiptCloseMessenger.Default.Register <Object>(this, OnReceiveReceiptClose);
UpdateSelectedTableAfterRemoveOrderMessenger.Default.Register <TableModel>(this, OnReceiveUpdateSelectedTable);
}
public void DidNotFindReceipt()
{
var service = new ReceiptService(new FakeFridgeItemRepository(), new FakeReceiptRepository());
var result = service.GetReceipt("xxx");
Assert.IsNull(result);
}
static void Main(string[] args)
{
//var promotions = new Promotion[]
//{
// new Promotion("Additional Sale test", "Orange", PromotionType.AdditionalSale, 2, 0, 0.5f, DateTime.UtcNow.AddDays(-2), DateTime.UtcNow.AddDays(1), null)
//};
//var json = JsonConvert.SerializeObject(promotions);
//System.Console.WriteLine(json);
var products = new FileReader("Files/items.txt")
.Read()
.Split("\n")
.Where(s => !string.IsNullOrWhiteSpace(s))
.Select(s => s.Trim());
var productRepository = new ProductRepository(new FileReader("Files/products.json"), new JsonTextSerializer());
var promotionRepository = new PromotionRepository(new FileReader("Files/promotions.json"), new JsonTextSerializer());
var saleService = new SaleService(productRepository, new PriceResolver(promotionRepository));
var sale = saleService.Checkout(products.ToArray());
var receiptService = new ReceiptService();
receiptService.Print(sale);
System.Console.Read();
}
public InitTestData(ReceiptService receiptService, InvoiceService invoiceService, ProductService productService, AddressService addressService)
{
this.invoiceService = invoiceService;
this.productService = productService;
this.addressService = addressService;
this.receiptService = receiptService;
}
public ReceiptsController(
ReceiptService receiptService,
UserService userService)
{
_receiptService = receiptService;
_userService = userService;
}
public async Task Receipt_processing_should_be_valid()
{
EventData[] eventsData = CreateIssueReceiptEventsData();
var eventCollectorMock = new Mock <IAsyncCollector <EventData> >();
var stateCollectorMock = new Mock <IAsyncCollector <ExecutedTransfer> >();
var loggerMock = new Mock <ILogger>();
eventCollectorMock
.Setup(x => x.AddAsync(It.IsAny <EventData>(), default))
.Returns(Task.CompletedTask);
stateCollectorMock
.Setup(x => x.AddAsync(It.IsAny <ExecutedTransfer>(), default))
.Returns(Task.CompletedTask);
await ReceiptService
.ReceiptCreator(eventsData, eventCollectorMock.Object, stateCollectorMock.Object, loggerMock.Object);
eventCollectorMock
.Verify(x => x.AddAsync(It.IsAny <EventData>(), default), Times.AtLeastOnce());
stateCollectorMock
.Verify(x => x.AddAsync(It.IsAny <ExecutedTransfer>(), default), Times.AtLeastOnce());
}
public MainScreen(ReceiptService receiptService)
{
_receiptService = receiptService;
_photoImageGetter = new PhotoImageGetter();
_fileImageGetter = new FileImageGetter();
InitializeComponent();
}
public async Task Init()
{
var options = new DbContextOptionsBuilder <MISDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString())
.Options;
this.dbContext = new MISDbContext(options);
var userService = new UserService(this.dbContext);
var companyService = new CompanyService(this.dbContext, userService);
var warehouseService = new WareHouseService(this.dbContext, companyService);
var categoryService = new CategoryService(warehouseService, this.dbContext);
var productService = new ProductService(this.dbContext, categoryService);
this.receiptService = new ReceiptService(this.dbContext, userService, companyService, productService);
var company = new Company()
{
Name = "asd",
Address = "asd",
};
await this.dbContext.AddAsync(company);
await this.dbContext.SaveChangesAsync();
var warehouse = new WareHouse()
{
Name = "asd",
Company = company,
};
var user = new MISUser()
{
UserName = "******",
Email = "*****@*****.**",
FirstName = "asdddd",
Company = company,
LastName = "asdddd",
};
await this.dbContext.AddAsync(warehouse);
await this.dbContext.AddAsync(user);
await this.dbContext.SaveChangesAsync();
var category = new Category()
{
Name = "asd",
WareHouse = warehouse
};
await this.dbContext.AddAsync(category);
await this.dbContext.SaveChangesAsync();
}
public void CreateReceipt_NoDiscount_ShouldBeCorrectPrice()
{
// Act
var receipt = ReceiptService.CreateReceipt(_cart);
// Assert
Assert.AreEqual(13.18M, receipt.TotalPrice);
}
public async Task <IActionResult> Index()
{
List <Receipt> receipts = new List <Receipt>();
ReceiptService service = new ReceiptService(_config, _httpContextAccessor);
var AllReceipts = await service.GetAll();
ViewBag.YourEnums = new Microsoft.AspNetCore.Mvc.Rendering.SelectList(Enum.GetValues(typeof(Currency)));
return(View(AllReceipts));
}
public async Task ForUserAsyncShouldReturnAllReceiptsForGivenUser()
{
var db = DbInfrastructure.GetDatabase();
var receiptService = new ReceiptService(db);
const string FirstUsername = "******";
var firstUser = new User
{
UserName = FirstUsername
};
var secondUser = new User
{
UserName = "******"
};
await db.AddRangeAsync(firstUser, secondUser);
await db.SaveChangesAsync();
for (var i = 0; i < 3; i++)
{
var receipt = new Receipt
{
Fee = (i + 1) * 10,
PackageId = i + 1,
RecipientId = firstUser.Id
};
await db.AddAsync(receipt);
}
for (var i = 0; i < 10; i++)
{
var receipt = new Receipt
{
Fee = (i + 1) * 10,
PackageId = i + 1,
RecipientId = secondUser.Id
};
await db.AddAsync(receipt);
}
await db.SaveChangesAsync();
var receipts = await receiptService.ForUserAsync(firstUser);
receipts.Should().HaveCount(3);
receipts.Should()
.Match(r => r.ElementAt(0).Fee == 10).And.Match(r => r.ElementAt(0).RecipientName == FirstUsername)
.And
.Match(r => r.ElementAt(1).Fee == 20).And.Match(r => r.ElementAt(1).RecipientName == FirstUsername)
.And
.Match(r => r.ElementAt(2).Fee == 30).And.Match(r => r.ElementAt(2).RecipientName == FirstUsername);
}
static void Main(string[] args)
{
Console.WriteLine("Input Items Seperated by \",\" : ");
string line = Console.ReadLine();
Console.WriteLine();
Console.WriteLine(ReceiptService.GetReceipt(line));
Console.ReadKey();
}
public ReceiptViewModel()
{
var container = ContainerConfig.Configure();
using var scope = container.BeginLifetimeScope();
var receiptRepository = scope.Resolve <ReceiptRepository>();
ReceiptService = new ReceiptService(receiptRepository);
}
public ReceiptController(SCMSContext _context)
{
var optionBuilder = new DbContextOptions <SCMSContext>();
_receiptRepository = new ReceiptRepository(_context);
_receiptItemRepository = new ReceiptItemRepository(_context);
_inventoryItemRepository = new InventoryItemRepository(_context);
_receiptService = new ReceiptService(_receiptRepository, _receiptItemRepository, _inventoryItemRepository);
}
public void ForUserAsyncShouldThrowInvalidOperationExceptionIfUserIsNull()
{
var db = DbInfrastructure.GetDatabase();
var receiptService = new ReceiptService(db);
Func<Task> func = async () => await receiptService.ForUserAsync(null);
func.Should().Throw<InvalidOperationException>();
}
public FormReceipt()
{
InitializeComponent();
_logService = new LogService();
_receiptService = new ReceiptService();
_productService = new ProductService();
_receiptDetailService = new ReceiptDetailService();
_inventoryService = new InventoryService();
}
public IReceiptService GetMockService()
{
var c = GetInMemoryContext();
var dalFacadeMock = GetDalFacadeMock(c);
//Creates the Service
IReceiptService service = new ReceiptService(dalFacadeMock.Object);
return(service);
}
public ReceiptController(ILogger <ReceiptController> logger)
{
_logger = logger;
api = new APIHelper();
rs = new ReceiptService();
attributes = new HashSet <string>
{
"TID", "ImgURL", "PurchaseDate", "Notes"
};
}
public void CreateReceipt_WithBonusAndExpiryDiscount_ShouldBeCorrectPrice()
{
_cart.Products[0].Discount = Discount.Bonus;
_cart.Products[2].Discount = Discount.Expiry;
_cart.Products[4].Discount = Discount.Bonus;
// Act
var receipt = ReceiptService.CreateReceipt(_cart);
// Assert
Assert.AreEqual(11.61M, receipt.TotalPrice);
}
public decimal GetEarnings(int month)
{
if (month + 1 == DateTime.Now.Month)
{
return(ReceiptService.GetMothEarning(DateTime.Now));
}
else
{
DateTime date = DateTime.Now.AddMonths(-12 + month);
return(ReceiptService.GetMothEarning(date));
}
}
public void Test()
{
var input = "Book at 12.49,1 Book at 12.49,1 Music CD at 14.99,1 Chocolate Bar at 0.85";
//var input = "1 Imported box of chocolates at 10.00\r\n1 Imported bottle of perfume at 47.50";
//var input = "1 Imported bottle of perfume at 47.50";
//var input = "1 Imported bottle of perfume at 27.99\r\n1 Bottle of perfume at 18.99\r\nPacket of headache pills at 9.75\r\nImported box of chocolates at 11.25\r\n1 Imported box of chocolates at 11.25";
//var input = "Imported box of chocolates at 11.25\r\n1 Imported box of chocolates at 11.25";
var expectedOutput = "Book: 24.98 (2 @ 12.49)\r\nMusic CD: 16.49\r\nChocolate bar: 0.85\r\nSales Taxes: 1.50\r\nTotal: 42.32";
Assert.AreEqual(expectedOutput, ReceiptService.GetReceipt(input));
}
public void Setup()
{
_mockReceiptQueue = new Mock <IReceiptQueue>();
_mockBalanceRepository = new Mock <IBalanceRepository>();
_mockAccountRepository = new Mock <IAccountRepository>();
_mockEntryRepository = new Mock <IEntryRepository>();
_service = new ReceiptService(_mockReceiptQueue.Object,
_mockBalanceRepository.Object,
_mockAccountRepository.Object,
_mockEntryRepository.Object);
}
public List <Availability> GetAvailableMeals()
{
var service = new ReceiptService(_fridgeProxy, _receiptRepository);
var possibleMeals = service.GetPossibleMeals();
var availabilities = new List <Availability>();
foreach (var meal in possibleMeals)
{
var availablilty = new Availability();
availablilty.Meal = meal.Meal;
availabilities.Add(availablilty);
}
return(availabilities);
}
public async Task ByIdAsyncShouldThrowInvalidOperationExceptionIfReceiptIsNotFound()
{
var db = DbInfrastructure.GetDatabase();
var receiptService = new ReceiptService(db);
var user = new User
{
UserName = "******"
};
await db.AddAsync(user);
await db.SaveChangesAsync();
Func<Task> func = async () => await receiptService.ByIdAsync(user, 1);
func.Should().Throw<InvalidOperationException>();
}
public void ReceiptService_NoImage_NullBitmap()
{
//arrange
var imageFormating = new Mock <IImageFormating>();
var receiptCreating = new Mock <IReceiptMaking>();
var dataConverter = new Mock <IDataConverter>();
var itemCategorization = new Mock <IItemCategorization>();
ReceiptService receiptService =
new ReceiptService(
imageFormating: imageFormating.Object,
receiptCreating: receiptCreating.Object,
dataConverter: dataConverter.Object,
itemCategorization: itemCategorization.Object);
//act
//assert
Assert.Null(receiptService.ProcessReceiptImage(null));
}
public void ReceiptService_NoImage_NullBitmap()
{
//arrange
var imageFormating = new Mock <IImageFormating>();
var ocr = new Mock <IOcr>();
var dataConverter = new Mock <IDataConverter>();
var dataManager = new Mock <IItemManager>();
ReceiptService receiptService =
new ReceiptService(
imageFormating: imageFormating.Object,
ocr: ocr.Object,
dataConverter: dataConverter.Object,
dataManager: dataManager.Object);
//act
//assert
Assert.Null(receiptService.ProcessReceiptImage(null));
}
public void PossibleToCookPancake()
{
var fakeRep = new FakeFridgeItemRepository();
var flourItem = new FridgeItem
{
Name = "Flour",
Quantity = new Quantity()
{
Unit = "L", Total = 1
}
};
fakeRep.Items.Add(flourItem);
var eggItem = new FridgeItem
{
Name = "Egg",
Quantity = new Quantity()
{
Unit = "P", Total = 8
}
};
fakeRep.Items.Add(eggItem);
var milkItem = new FridgeItem
{
Name = "Milk",
Quantity = new Quantity()
{
Unit = "L", Total = 2
}
};
fakeRep.Items.Add(milkItem);
var worker = new ReceiptService(fakeRep, new FakeReceiptRepository());
var result = worker.PossibleToCook(worker.GetReceipt(PancakeReceipt));
Assert.IsTrue(result);
}
