public async Task <MutationResult> ValidateAsync(VehicleMutationsHandler handler)
{
if (string.IsNullOrWhiteSpace(Id))
{
return(new MutationResult(EStatusCode.InvalidData, $"Paramter {nameof(Id)} is require"));
}
if (PricePurchase <= 0)
{
return(new MutationResult(EStatusCode.InvalidData, $"Paramter {nameof(PricePurchase)} require positive"));
}
if (PriceSale <= 0)
{
return(new MutationResult(EStatusCode.InvalidData, $"Paramter {nameof(PriceSale)} require positive"));
}
if (string.IsNullOrWhiteSpace(VehicleId))
{
return(new MutationResult(EStatusCode.InvalidData, $"Parameter {nameof(VehicleId)} is required"));
}
var exists = await handler.DbContext.Announcements.AnyAsync(a => a.Id == Id);
if (!exists)
{
return(new MutationResult(EStatusCode.NotFound, $"Announcement with id: {Id} does not exists"));
}
var existsVehicle = await handler.DbContext.Vehicles.AnyAsync(v => v.Id == VehicleId);
if (!existsVehicle)
{
return(new MutationResult(EStatusCode.NotFound, $"Vehicle with id: {VehicleId} does not exists"));
}
return(null);
}
public async Task <MutationResult> ExecuteAsync(VehicleMutationsHandler handler)
{
var vehicle = await handler.DbContext.Vehicles.FindAsync(Id);
vehicle.SetData(
year: Year,
color: ColorId,
fuel: FuelId,
modelId: ModelId,
photoDate: string.IsNullOrWhiteSpace(ImageBase64)
? null
: (Nullable <DateTime>)DateTime.Now
);
var fileName = $"{vehicle.Id}.jpg";
if (!string.IsNullOrWhiteSpace(ImageBase64))
{
await Base64.SaveAsync(ImageBase64, EPath.Photos, fileName);
}
else
{
Base64.Remove(EPath.Photos, fileName);
}
handler.DbContext.Update(vehicle);
var rows = await handler.DbContext.SaveChangesAsync();
return(new MutationResult(rows));
}
public async Task <MutationResult> ValidateAsync(VehicleMutationsHandler handler)
{
if (string.IsNullOrWhiteSpace(Id))
{
return(new MutationResult(EStatusCode.InvalidData, $"Parameter {nameof(Id)} is required"));
}
if (Year <= 1950)
{
return(new MutationResult(EStatusCode.InvalidData, $"Paramter {nameof(Year)} require upper 150"));
}
if (!Enum.IsDefined(typeof(EFuel), FuelId))
{
return(new MutationResult(EStatusCode.InvalidData, $"Parameter {nameof(FuelId)} is required"));
}
if (!Enum.IsDefined(typeof(EColor), ColorId))
{
return(new MutationResult(EStatusCode.InvalidData, $"Parameter {nameof(ColorId)} is required"));
}
if (string.IsNullOrWhiteSpace(ModelId))
{
return(new MutationResult(EStatusCode.InvalidData, $"Parameter {nameof(ModelId)} is required"));
}
var existsModel = await handler.DbContext.Models.AnyAsync(m => m.Id == ModelId);
if (!existsModel)
{
return(new MutationResult(EStatusCode.NotFound, $"Model with id: {ModelId} does not exsits"));
}
return(null);
}
public async Task <MutationResult> ValidateAsync(VehicleMutationsHandler handler)
{
if (string.IsNullOrWhiteSpace(Id))
{
return(new MutationResult(EStatusCode.InvalidData, $"Parameter {nameof(Id)} is require"));
}
if (string.IsNullOrWhiteSpace(ContactName) || ContactName.Length > 150)
{
return(new MutationResult(EStatusCode.InvalidData, $"Parameter {ContactName} invalid"));
}
if (string.IsNullOrWhiteSpace(ContactPhone) || ContactPhone.Length > 15)
{
return(new MutationResult(EStatusCode.InvalidData, $"Parameter {ContactPhone} invalid"));
}
if (string.IsNullOrWhiteSpace(AnnouncementId))
{
return(new MutationResult(EStatusCode.InvalidData, $"Parameter {nameof(AnnouncementId)} is required"));
}
var existsPhone = await handler.DbContext.Contacts.AnyAsync(c => c.Name != ContactName && c.Phone == ContactPhone);
if (existsPhone)
{
return(new MutationResult(EStatusCode.Conflict, $"Contact with {nameof(ContactPhone)} already exists"));
}
var existsAnnouncement = await handler.DbContext.Announcements.AnyAsync(a => a.Id == AnnouncementId);
if (!existsAnnouncement)
{
return(new MutationResult(EStatusCode.NotFound, $"Announcement with id: {AnnouncementId} does not exists"));
}
return(null);
}
public async Task <MutationResult> ExecuteAsync(VehicleMutationsHandler handler)
{
var contact = await handler.DbContext.Contacts
.Where(c => c.Name == ContactName && c.Phone == ContactPhone)
.FirstOrDefaultAsync();
if (contact == null)
{
contact = new Contact(
id: RandomId.NewId(),
name: ContactName,
phone: ContactPhone
);
await handler.DbContext.AddAsync(contact);
}
var reservation = new Reservation(
id: Id,
contactId: contact.Id,
announcementId: AnnouncementId
);
await handler.DbContext.AddAsync(reservation);
var rows = await handler.DbContext.SaveChangesAsync();
return(new MutationResult(rows));
}
public async Task <MutationResult> ValidateAsync(VehicleMutationsHandler handler)
{
if (string.IsNullOrWhiteSpace(Id))
{
return(new MutationResult(EStatusCode.InvalidData, $"Parameter {nameof(Id)} is required"));
}
if (string.IsNullOrWhiteSpace(Name) || Name.Length > 200)
{
return(new MutationResult(EStatusCode.InvalidData, $"Paramter {nameof(Name)} is invalid"));
}
if (string.IsNullOrWhiteSpace(BrandId))
{
return(new MutationResult(EStatusCode.InvalidData, $"Paramter {nameof(BrandId)} is required"));
}
var existsName = await handler.DbContext.Models.AnyAsync(m => m.Name == Name);
if (existsName)
{
return(new MutationResult(EStatusCode.Conflict, $"Model with {nameof(Name)} already exists"));
}
var existsBrand = await handler.DbContext.Brands.AnyAsync(b => b.Id == BrandId);
if (!existsBrand)
{
return(new MutationResult(EStatusCode.NotFound, $"Brand with id: {BrandId} does not exists"));
}
return(null);
}
public async Task <MutationResult> ExecuteAsync(VehicleMutationsHandler handler)
{
var announcement = await handler.DbContext.Announcements.FindAsync(Id);
handler.DbContext.Remove(announcement);
var rows = await handler.DbContext.SaveChangesAsync();
return(new MutationResult(rows));
}
public AuthenticationHandler(
IOptionsMonitor <AuthenticationSchemeOptions> options,
ILoggerFactory logger, UrlEncoder encoder, ISystemClock clock,
VehicleMutationsHandler mutationsHandler, VehicleQueriesHandler queriesHandler
) : base(options, logger, encoder, clock)
{
_mutationsHanlder = mutationsHandler;
_queriesHanlder = queriesHandler;
}
public async Task <MutationResult> ExecuteAsync(VehicleMutationsHandler handler)
{
var brand = await handler.DbContext.Brands.FindAsync(Id);
handler.DbContext.Brands.Remove(brand);
var rows = await handler.DbContext.SaveChangesAsync();
return(new MutationResult(rows));
}
public BaseTests(VehicleFixture fixture, string url)
{
Request = fixture.Request;
EntitiesFactory = fixture.EntitiesFactory;
MutationsDbContext = fixture.MutationsHandler.DbContext;
MutationsHandler = fixture.MutationsHandler;
QueriesHandler = fixture.QueriesHandler;
Uri = new Uri($"{fixture.Client.BaseAddress}{url}");
}
public async Task <MutationResult> ExecuteAsync(VehicleMutationsHandler handler)
{
var vehicle = await handler.DbContext.Vehicles.FindAsync(Id);
vehicle.Sell(DateSale.Value.Date);
handler.DbContext.Update(vehicle);
var rows = await handler.DbContext.SaveChangesAsync();
return(new MutationResult(rows));
}
public async Task <MutationResult> ExecuteAsync(VehicleMutationsHandler handler)
{
var brand = new Brand(
id: Id,
name: Name
);
await handler.DbContext.Brands.AddAsync(brand);
var rows = await handler.DbContext.SaveChangesAsync();
return(new MutationResult(rows));
}
public async Task <MutationResult> ExecuteAsync(VehicleMutationsHandler handler)
{
var vehicle = await handler.DbContext.Vehicles.FindAsync(Id);
handler.DbContext.Remove(vehicle);
var fileName = $"{vehicle.Id}.jpg";
Base64.Remove(EPath.Photos, fileName);
var rows = await handler.DbContext.SaveChangesAsync();
return(new MutationResult(rows));
}
public async Task <MutationResult> ExecuteAsync(VehicleMutationsHandler handler)
{
var model = await handler.DbContext.Models.FindAsync(Id);
model.SetData(
name: Name,
brandId: BrandId
);
handler.DbContext.Models.Update(model);
var rows = await handler.DbContext.SaveChangesAsync();
return(new MutationResult(rows));
}
public async Task <MutationResult> ValidateAsync(VehicleMutationsHandler handler)
{
if (string.IsNullOrWhiteSpace(Id))
{
return(new MutationResult(EStatusCode.InvalidData, $"Paramter {nameof(Id)} is required"));
}
var exists = await handler.DbContext.Brands.AnyAsync(b => b.Id == Id);
if (!exists)
{
return(new MutationResult(EStatusCode.NotFound, $"Brand with {nameof(Id)} does not exists"));
}
return(null);
}
public async Task <MutationResult> ExecuteAsync(VehicleMutationsHandler handler)
{
var model = new Model(
id: Id,
name: Name,
brandId: BrandId
);
await handler.DbContext.Models.AddAsync(model);
var rows = await handler.DbContext.SaveChangesAsync();
return(new MutationResult(rows));
}
public async Task <MutationResult> ExecuteAsync(VehicleMutationsHandler handler)
{
var reservation = await handler.DbContext.Reservations
.Include(i => i.Announcement)
.Where(r => r.Id == Id)
.FirstOrDefaultAsync();
reservation.SetDateSale(DateSale.Value.Date);
reservation.Announcement.SetDateSale(DateSale.Value.Date);
handler.DbContext.Update(reservation);
var rows = await handler.DbContext.SaveChangesAsync();
return(new MutationResult(rows));
}
public async Task <MutationResult> ExecuteAsync(VehicleMutationsHandler handler)
{
var announcement = new Announcement(
id: Id,
pricePurchase: PricePurchase,
priceSale: PriceSale,
vehicleId: VehicleId,
dateSale: null
);
await handler.DbContext.AddAsync(announcement);
var rows = await handler.DbContext.SaveChangesAsync();
return(new MutationResult(rows));
}
public VehicleFixture()
{
var builder = new DbContextOptionsBuilder <VehicleMutationsDbContext>()
.UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString())
.EnableSensitiveDataLogging()
.EnableDetailedErrors();
var mutationsDbContext = new VehicleMutationsDbContext(builder.Options);
MutationsHandler = new VehicleMutationsHandler(mutationsDbContext);
VehicleStartup.Configure(
secret: string.Empty,
pathFiles: string.Empty
);
}
public async Task <MutationResult> ExecuteAsync(VehicleMutationsHandler handler)
{
var announcement = await handler.DbContext.Announcements.FindAsync(Id);
announcement.SetData(
pricePurchase: PricePurchase,
priceSale: PriceSale,
dateSale: announcement.DateSale,
vehicleId: VehicleId
);
handler.DbContext.Update(announcement);
var rows = await handler.DbContext.SaveChangesAsync();
return(new MutationResult(rows));
}
public async Task <MutationResult> ValidateAsync(VehicleMutationsHandler handler)
{
if (string.IsNullOrWhiteSpace(Login))
{
return(new MutationResult(EStatusCode.InvalidData, $"Parameter {nameof(Login)} is require"));
}
if (string.IsNullOrWhiteSpace(Password))
{
return(new MutationResult(EStatusCode.InvalidData, $"Parameter {nameof(Password)} is require"));
}
var exists = await handler.DbContext.Users.AnyAsync(u => u.Login == Login);
if (!exists)
{
return(new MutationResult(EStatusCode.Unauthorized, "Login fail"));
}
return(null);
}
public async Task <MutationResult> ValidateAsync(VehicleMutationsHandler handler)
{
if (string.IsNullOrWhiteSpace(Id))
{
return(new MutationResult(EStatusCode.InvalidData, $"Parameter {nameof(Id)} is require"));
}
if (DateSale == null)
{
return(new MutationResult(EStatusCode.InvalidData, $"Parameter {nameof(DateSale)} require"));
}
var exists = await handler.DbContext.Reservations.AnyAsync(a => a.Id == Id);
if (!exists)
{
return(new MutationResult(EStatusCode.NotFound, $"Reservation with id: {Id} does not exists"));
}
return(null);
}
public async Task <MutationResult> ValidateAsync(VehicleMutationsHandler handler)
{
if (string.IsNullOrWhiteSpace(Id))
{
return(new MutationResult(EStatusCode.InvalidData, $"Paramter {nameof(Id)} is required"));
}
if (string.IsNullOrWhiteSpace(Name) || Name.Length > 200)
{
return(new MutationResult(EStatusCode.InvalidData, $"Parameter {nameof(Name)} is invalid"));
}
var existsName = await handler.DbContext.Brands.AnyAsync(b => b.Name == Name);
if (existsName)
{
return(new MutationResult(EStatusCode.Conflict, $"Brand with {nameof(Name)} already exists"));
}
return(await Task.FromResult <MutationResult>(null));
}
public async Task <MutationResult> ExecuteAsync(VehicleMutationsHandler handler)
{
var reservation = await handler.DbContext.Reservations
.Include(i => i.Contact)
.Where(r => r.Id == Id)
.FirstOrDefaultAsync();
reservation.SetData(
announcementId: AnnouncementId,
contact: reservation.Contact
);
reservation.Contact.SetData(
name: ContactName,
phone: ContactPhone
);
handler.DbContext.Update(reservation);
var rows = await handler.DbContext.SaveChangesAsync();
return(new MutationResult(rows));
}
public async Task <MutationResult> ExecuteAsync(VehicleMutationsHandler handler)
{
var user = await handler.DbContext.Users
.Where(u => u.Login == Login)
.FirstOrDefaultAsync();
var valid = user.ValidatePassword(Password);
if (!valid)
{
return(new MutationResult(EStatusCode.Unauthorized, "Login fail"));
}
var result = new LoginResult {
Id = user.Id,
Name = user.Name,
Token = new TokenData(user.Id).Generate()
};
return(new MutationResult(EStatusCode.Success, "Login successfull", result));
}
private void ConfigureServices(IServiceCollection services)
{
var contentRoot = GetProjectPath();
var manager = new ApplicationPartManager
{
ApplicationParts =
{
new AssemblyPart(typeof(Startup).GetTypeInfo().Assembly)
},
FeatureProviders =
{
new ControllerFeatureProvider(),
new ViewComponentFeatureProvider()
}
};
services.AddDbContext <VehicleMutationsDbContext>(options => options
.UseMySql(Configuration.GetConnectionString("VehicleMutations"))
.EnableDetailedErrors()
);
services.AddDbContext <VehicleQueriesDbContext>(options => options
.UseMySql(Configuration.GetConnectionString("VehicleQueries"))
.EnableDetailedErrors()
);
var scope = services
.BuildServiceProvider()
.CreateScope();
var scopedServices = scope.ServiceProvider;
MutationsDbContext = scopedServices.GetRequiredService <VehicleMutationsDbContext>();
QueriesDbContext = scopedServices.GetRequiredService <VehicleQueriesDbContext>();
MutationsHandler = new VehicleMutationsHandler(MutationsDbContext);
QueriesHandler = new VehicleQueriesHandler(QueriesDbContext);
EntitiesFactory = new EntitiesFactory(MutationsDbContext);
MutationsDbContext.Database.EnsureCreated();
services.AddSingleton(manager);
}
public async Task <MutationResult> ExecuteAsync(VehicleMutationsHandler handler)
{
var vehicle = new Entities.Vehicle(
id: Id,
year: Year,
fuel: FuelId,
color: ColorId,
modelId: ModelId,
photoDate: string.IsNullOrWhiteSpace(ImageBase64)
? null
: (Nullable <DateTime>)DateTime.Now
);
if (!string.IsNullOrWhiteSpace(ImageBase64))
{
await Base64.SaveAsync(ImageBase64, EPath.Photos, $"{vehicle.Id}.jpg");
}
await handler.DbContext.Vehicles.AddAsync(vehicle);
var rows = await handler.DbContext.SaveChangesAsync();
return(new MutationResult(rows));
}
public async Task <MutationResult> ValidateAsync(VehicleMutationsHandler handler)
{
if (string.IsNullOrWhiteSpace(Id))
{
return(new MutationResult(EStatusCode.InvalidData, $"Parameter {nameof(Id)} is required"));
}
if (DateSale == null)
{
return(new MutationResult(EStatusCode.InvalidData, $"Paramter {nameof(DateSale)} is require"));
}
var existsVehicle = await handler.DbContext.Vehicles.AnyAsync(v => v.Id == Id);
if (!existsVehicle)
{
return(new MutationResult(EStatusCode.NotFound, $"Vehicle with id: {Id} does not exists"));
}
var existsAnnouncement = await handler.DbContext.Announcements.AnyAsync(a => a.VehicleId == Id && a.DateSale == null);
if (!existsAnnouncement)
{
return(new MutationResult(EStatusCode.NotFound, $"Announcement by VehicleId: {Id} does not exists or already Sell"));
}
return(null);
}
public VehiclesController(VehicleMutationsHandler mutationsHandler, VehicleQueriesHandler queriesHandler)
{
_mutationsHanlder = mutationsHandler;
_queriesHanlder = queriesHandler;
}
protected TestsBase(VehicleFixture fixture)
{
EntitiesFactory = new EntitiesFactory(fixture.MutationsHandler.DbContext);
MutationsDbContext = fixture.MutationsHandler.DbContext;
MutationsHandler = fixture.MutationsHandler;
}
