public async Task UserHasPurchasedBookAsync_WithNullBookId_ReturnsFalse()
{
// Arrange
var context = this.NewInMemoryDatabase();
var testUser = new KnigaUser {
UserName = "******"
};
var testBook = new Book();
await context.Books.AddAsync(testBook);
await context.Users.AddAsync(testUser);
var purchase = new Purchase
{
UserId = testUser.Id,
BookId = testBook.Id,
PurchaseDate = DateTime.UtcNow
};
await context.Purchases.AddAsync(purchase);
await context.SaveChangesAsync();
var purchasesService = new PurchasesService(context);
// Act
var result = await purchasesService.UserHasPurchasedBookAsync(null, testUser.UserName);
// Assert
Assert.False(result);
}
public async Task GetPurchasesForPublisherAsync_WithNoPurchases_ReturnsEmptyCollection()
{
// Arrange
var context = this.NewInMemoryDatabase();
await context.Purchases.AddAsync(new Purchase
{
Book = new Book
{
PublisherId = Guid.NewGuid().ToString()
},
User = new KnigaUser
{
Email = "[email protected]"
}
});
await context.SaveChangesAsync();
var purchasesService = new PurchasesService(context);
// Act
var result = await purchasesService.GetPurchasesForPublisherAsync(Guid.NewGuid().ToString());
// Assert
Assert.Empty(result);
}
public async Task <IActionResult> FormOfferNoTemplate(object offer)
{
BasePurchases basePurchases = new PurchasesService(_db);
await basePurchases.FormOfferNoTemplate(offer);
return(Ok("Коммерческое предложение успешно создано"));
}
public async Task CreateAsync_WithNonexistentUser_ReturnsFalse()
{
// Arrange
var context = this.NewInMemoryDatabase();
var testBook = new Book();
await context.Books.AddAsync(testBook);
await context.SaveChangesAsync();
var serviceModel = new PurchaseCreateServiceModel
{
UserName = "******",
BookId = testBook.Id,
PurchaseDate = DateTime.UtcNow
};
var purchasesService = new PurchasesService(context);
// Act
var result = await purchasesService.CreateAsync(serviceModel);
// Assert
Assert.False(result);
Assert.False(await context.Purchases.AnyAsync());
}
public async Task CreateAsync_WithNonexistentBook_ReturnsFalse()
{
// Arrange
var context = this.NewInMemoryDatabase();
var testUser = new KnigaUser {
UserName = "******"
};
await context.Users.AddAsync(testUser);
await context.SaveChangesAsync();
var serviceModel = new PurchaseCreateServiceModel
{
UserName = testUser.UserName,
BookId = Guid.NewGuid().ToString(),
PurchaseDate = DateTime.UtcNow
};
var purchasesService = new PurchasesService(context);
// Act
var result = await purchasesService.CreateAsync(serviceModel);
// Assert
Assert.False(result);
Assert.False(await context.Purchases.AnyAsync());
}
public ReturnPurchasesManager(ReturnPurchasesService returnPurchasesService,
PurchasesService purchasesService,
PurchaseUnitsService purchaseUnitsService) : base(returnPurchasesService)
{
_returnPurchasesService = returnPurchasesService;
_purchasesService = purchasesService;
_purchaseUnitsService = purchaseUnitsService;
}
public async Task GetPurchasesForUserAsync_WithCorrectUserName_WorksCorrectly()
{
// Arrange
var context = this.NewInMemoryDatabase();
var expectedResult = new[] { "Book1", "Book0" };
var testUser = new KnigaUser {
UserName = "******"
};
var otherUser = new KnigaUser {
UserName = "******"
};
await context.Users.AddRangeAsync(
testUser,
otherUser
);
await context.Purchases.AddRangeAsync(
new Purchase
{
UserId = testUser.Id,
PurchaseDate = DateTime.UtcNow,
Book = new Book {
Title = "Book0"
}
},
new Purchase
{
UserId = testUser.Id,
PurchaseDate = DateTime.UtcNow.AddDays(1),
Book = new Book {
Title = "Book1"
}
},
new Purchase
{
UserId = otherUser.Id,
PurchaseDate = DateTime.UtcNow,
Book = new Book {
Title = "Book2"
}
}
);
await context.SaveChangesAsync();
var purchasesService = new PurchasesService(context);
// Act
var actualResult = (await purchasesService.GetPurchasesForUserAsync("TestUser"))
.Select(p => p.Book.Title)
.ToArray();
// Assert
Assert.Equal(2, actualResult.Length);
Assert.Equal(expectedResult, actualResult);
}
protected override void Load()
{
Instance = this;
MessageColor = UnturnedChat.GetColorFromName(Configuration.Instance.MessageColor, UnityEngine.Color.green);
PurchasesService = gameObject.AddComponent <PurchasesService>();
Logger.Log($"{Name} {Assembly.GetName().Version} has been loaded!", ConsoleColor.Yellow);
}
public DebtsService(
WiseContext db,
PurchasesService purchasesService,
AvatarsService avatarsService)
{
_db = db;
_purchasesService = purchasesService;
_avatarsService = avatarsService;
}
public PurchasesServiceUnitTests()
{
var options = new DbContextOptionsBuilder <PurchasesDbContext>()
.UseInMemoryDatabase("test_purchases");
_purchasesContext = new PurchasesDbContext(options.Options);
InitialContext();
_purchasesService = new PurchasesService(_purchasesContext);
}
public async Task GetAllPurchasesAsync_WithCorrectData_WorksCorrectly()
{
// Arrange
var context = this.NewInMemoryDatabase();
var publisherId = Guid.NewGuid().ToString();
var expectedPurchases = new[]
{
new Purchase
{
Book = new Book
{
PublisherId = publisherId,
Title = "C#"
},
User = new KnigaUser
{
Email = "[email protected]"
},
PurchaseDate = DateTime.UtcNow
},
new Purchase
{
Book = new Book
{
PublisherId = publisherId,
Title = "Java"
},
User = new KnigaUser
{
Email = "[email protected]"
},
PurchaseDate = DateTime.UtcNow.AddDays(1)
}
};
await context.Purchases.AddRangeAsync(expectedPurchases);
await context.SaveChangesAsync();
var expectedTitle = expectedPurchases.OrderByDescending(p => p.PurchaseDate).First().Book.Title;
var purchasesService = new PurchasesService(context);
// Act
var actualPurchases = (await purchasesService.GetAllPurchasesAsync()).ToArray();
var actualTitle = actualPurchases.First().Book.Title;
// Assert
Assert.NotNull(actualPurchases);
Assert.Equal(2, actualPurchases.Length);
Assert.Equal(expectedTitle, actualTitle);
}
public IActionResult VatCalculator(VatCalculatorViewModel model, PurchasesService svc)
{
List <PurchasesVat> VatEntries = new List <PurchasesVat>(svc.GetLatestPurchasesVat());
model.Diesel = VatEntries[0];
model.Super = VatEntries[1];
model.Vpower = VatEntries[2];
model.Kerosene = VatEntries[3];
return(View(model));
}
public PurchasesController(
PurchasesService purchasesService,
UserManager <User> userManager,
ICurrentUserAccessor currentUser,
IMapper mapper)
{
_userManager = userManager;
_purchasesService = purchasesService;
_currentUser = currentUser;
_mapper = mapper;
}
public DeliveriesManager(DeliveriesService deliveriesService,
PurchasesService purchasesService,
DeliveryPurchasesService deliveryPurchasesService,
PurchaseUnitsService purchaseUnitsService,
DriversService driversService) : base(deliveriesService)
{
_deliveriesService = deliveriesService;
_purchaseUnitsService = purchaseUnitsService;
_deliveryPurchasesService = deliveryPurchasesService;
_deliveryPurchasesService = deliveryPurchasesService;
_driversService = driversService;
}
public async Task GetAllPurchasesAsync_WithNoPurchases_ReturnsEmptyCollection()
{
// Arrange
var context = this.NewInMemoryDatabase();
var purchasesService = new PurchasesService(context);
// Act
var result = await purchasesService.GetAllPurchasesAsync();
// Assert
Assert.Empty(result);
}
public PurchasesManager(PurchasesService service,
PurchaseUnitsService purchaseUnitsService,
DeliveriesService deliveriesService,
ProductsService productsService,
ContactsService contactsService,
DeliveryPurchasesService deliveryPurchasesService) : base(service)
{
_deliveriesService = deliveriesService;
_productsService = productsService;
_purchasesService = service;
_purchaseUnitsService = purchaseUnitsService;
_contactsService = contactsService;
_deliveryPurchasesService = deliveryPurchasesService;
}
public UsersController(
UsersService usersService,
TeamsService teamsService,
PurchasesService purchasesService,
UserManager <User> userManager,
ICurrentUserAccessor currentUser,
AvatarsService avatarsService,
IMapper mapper)
{
_userManager = userManager;
_usersService = usersService;
_teamsService = teamsService;
_purchasesService = purchasesService;
_currentUser = currentUser;
_mapper = mapper;
_avatarsService = avatarsService;
}
public async Task CreateAsync_WithExistingPurchase_ReturnsFalse()
{
// Arrange
var context = this.NewInMemoryDatabase();
var testUser = new KnigaUser {
UserName = "******"
};
var testBook = new Book();
await context.Books.AddAsync(testBook);
await context.Users.AddAsync(testUser);
var purchase = new Purchase
{
UserId = testUser.Id,
BookId = testBook.Id,
PurchaseDate = DateTime.UtcNow
};
await context.Purchases.AddAsync(purchase);
await context.SaveChangesAsync();
var serviceModel = new PurchaseCreateServiceModel
{
UserName = testUser.UserName,
BookId = testBook.Id,
PurchaseDate = DateTime.UtcNow
};
var purchasesService = new PurchasesService(context);
// Act
var result = await purchasesService.CreateAsync(serviceModel);
// Assert
Assert.False(result);
Assert.True(await context.Purchases.AnyAsync(p => p.User.UserName == testUser.UserName));
Assert.Equal(1, await context.Purchases.CountAsync());
}
public async Task GetPurchasesForUserAsync_WithNoPurchasesForUser_ReturnsEmptyCollection()
{
// Arrange
var context = this.NewInMemoryDatabase();
var testUser = new KnigaUser {
UserName = "******"
};
await context.Users.AddAsync(testUser);
await context.Purchases.AddRangeAsync(new Purchase
{
UserId = testUser.Id,
PurchaseDate = DateTime.UtcNow.AddDays(1),
Book = new Book {
Title = "Book2"
}
},
new Purchase
{
UserId = testUser.Id,
PurchaseDate = DateTime.UtcNow,
Book = new Book {
Title = "Book1"
}
}
);
await context.SaveChangesAsync();
var purchasesService = new PurchasesService(context);
// Act
var actualResult = (await purchasesService.GetPurchasesForUserAsync("OtherUser"));
// Assert
Assert.Empty(actualResult);
}
public async Task CreateAsync_WithCorrectModel_WorksCorrectly()
{
// Arrange
var context = this.NewInMemoryDatabase();
var testUser = new KnigaUser {
UserName = "******"
};
var testBook = new Book();
await context.Books.AddAsync(testBook);
await context.Users.AddAsync(testUser);
await context.SaveChangesAsync();
var serviceModel = new PurchaseCreateServiceModel
{
UserName = testUser.UserName,
BookId = testBook.Id,
PurchaseDate = DateTime.UtcNow
};
var purchasesService = new PurchasesService(context);
// Act
var result = await purchasesService.CreateAsync(serviceModel);
// Assert
Assert.True(result);
var purchase = await context.Purchases.SingleOrDefaultAsync();
Assert.NotNull(purchase);
Assert.Equal(testUser.Id, purchase.UserId);
Assert.Equal(testBook.Id, purchase.BookId);
Assert.Equal(serviceModel.PurchaseDate, purchase.PurchaseDate);
}
public IActionResult Index(PurchaseViewModel model, PurchasesService service)
{
model.Purchases = service.GetPurchases(model.Date1x, model.Date2x, null, null, null);
return(View(model));
}
public IActionResult VATFilesDownloads(int month, int year, VatFilesDownloadViewModel model, PurchasesService Service)
{
model.Month = month;
model.Year = year;
model.Date = new DateTime(year, month, 1);
model.Purchases00Perc = Service.GetPurchases00PercEntries(month, year);
model.Purchases08Perc = Service.GetPurchases08PercEntries(month, year);
model.Purchases16Perc = Service.GetPurchases16PercEntries(month, year);
return(View(model));
}
public async Task Consume(ConsumeContext <GetTransactionByIdRequest> context)
{
var order = await PurchasesService.GetTransactionById(context.Message.User, context.Message.Id);
await context.RespondAsync(order);
}
public PurchaseUnitsManager(PurchaseUnitsService purchaseUnitsService, PurchasesService purchasesService, ProductsService productsService) : base(purchaseUnitsService)
{
_purchasesService = purchasesService;
_productsService = productsService;
_purchaseUnitsService = purchaseUnitsService;
}
public async Task Consume(ConsumeContext <AddTransactionRequest> context)
{
var order = await PurchasesService.AddTransaction(context.Message.User, context.Message.Transaction);
await context.RespondAsync(order);
}
public async Task Consume(ConsumeContext <User> context)
{
var order = await PurchasesService.GetTransactions(context.Message);
await context.RespondAsync(order);
}
public Double GetFuelPurchasesLedgerOpenning(Int64 stid, string date, PurchasesService svc)
{
return(svc.GetFuelPurchasesLedgerOpenning(stid, DateTime.Parse(date)));
}
public async Task <IActionResult> GetDataRequest([FromQuery] int number)
{
BasePurchases basePurchases = new PurchasesService(_db);
return(Ok(await basePurchases.GetDataRequest(number)));
}
public async Task <IActionResult> GetRequests()
{
BasePurchases basePurchases = new PurchasesService(_db);
return(Ok(await basePurchases.GetRequests()));
}
