public async Task <ActionResult> Create(ApartmentBooking model)
{
//if (ModelState.IsValid)
{
var errorsResult = ApartmentBookingValidationContext.Validate(model);
if (errorsResult.Any())
{
ModelState.Clear();
foreach (var error in errorsResult)
{
ModelState.AddModelError(error.Key, error.Value);
}
TempData["ValidationErrors"] = true;
return(View(model));
}
else
{
db.ApartmentBookings.Add(model);
await db.SaveChangesAsync();
}
return(RedirectToAction("Index"));
}
//return View(model);
}
public async Task Add(Note note)
{
if (note != null)
{
_dbContext.Notes.Add(note);
await _dbContext.SaveChangesAsync();
}
}
public async Task <IActionResult> Create([Bind("Id,Name,Phone,Email")] Customer customer)
{
if (ModelState.IsValid)
{
_context.Add(customer);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(customer));
}
public async Task <IActionResult> Create([Bind("ID,Name")] ServiceType serviceType)
{
if (ModelState.IsValid)
{
_context.Add(serviceType);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(serviceType));
}
public async Task <ActionResult> Create(Etudiant etudiant)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
_context.Etudiants.Add(etudiant);
await _context.SaveChangesAsync();
return(Ok());
}
public async Task <IActionResult> Create([Bind("Id,Title,DateCreated,DateModified,Details")] Note note)
{
if (ModelState.IsValid)
{
_context.Add(note);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(note));
}
public async Task <IActionResult> Create([Bind("MyTaskwakeGUID,TaskwakeDetail")] MyTaskwake myTaskwake)
{
if (ModelState.IsValid)
{
myTaskwake.MyTaskwakeGUID = Guid.NewGuid();
_context.Add(myTaskwake);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(TaskwakeDetail)));
}
return(View(myTaskwake));
}
public async Task <IActionResult> Create([Bind("Id,CustomerId,AddressFrom,AddressTo,ServiceType,TextField,Date")] Order order)
{
if (order.Id > 0)
{
order.Id = 0;
}
if (ModelState.IsValid)
{
_context.Add(order);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
ViewData["CustomerId"] = new SelectList(_context.Customers, "Id", "Id", order.CustomerId);
return(View(order));
}
public async Task <UserData> AddUserData(ParaboleModel model)
{
var userdata = db.UserData.Add(new UserData
{
RangeFrom = model.RangeFrom,
RangeTo = model.RangeTo,
step = model.step,
a = model.a,
b = model.b,
c = model.c
});
await db.SaveChangesAsync();
return(userdata);
}
public async Task Handle(MyMessage message, IMessageHandlerContext context)
{
dataContext.MyEntities.Add(new MyEntity {
Id = message.Id
});
await dataContext.SaveChangesAsync().ConfigureAwait(false);
}
public async Task DeleteStorage(int id)
{
using (var storageDbContext = new MyDataContext())
{
var deleteStorage = await GetStorageById(id);
storageDbContext.Storages.Remove(deleteStorage);
await storageDbContext.SaveChangesAsync();
}
}
public async Task <Storage> CreateStoragee(Storage storage)
{
using (var storageDbContext = new MyDataContext())
{
storageDbContext.Storages.Add(storage);
await storageDbContext.SaveChangesAsync();
return(storage);
}
}
public async Task <ActiveSubstance> UpdateActiveSubstance(ActiveSubstance activeSubstance)
{
using (var activeSubstanceDbContext = new MyDataContext())
{
activeSubstanceDbContext.ActiveSubstances.Update(activeSubstance);
await activeSubstanceDbContext.SaveChangesAsync();
return(activeSubstance);
}
}
public async Task <Medicine> UpdateMedicine(Medicine medicine)
{
using (var medicineDbContext = new MyDataContext())
{
medicineDbContext.Medicines.Update(medicine);
await medicineDbContext.SaveChangesAsync();
return(medicine);
}
}
public async Task DeleteMedicine(int id)
{
using (var medicineDbContext = new MyDataContext())
{
var deleteMedicine = await GetMedicineById(id);
medicineDbContext.Medicines.Remove(deleteMedicine);
await medicineDbContext.SaveChangesAsync();
}
}
public async Task DeleteActiveSubstance(int id)
{
using (var activeSubstanceDbContext = new MyDataContext())
{
var deleteActiveSubstance = await GetActiveSubstanceById(id);
activeSubstanceDbContext.ActiveSubstances.Remove(deleteActiveSubstance);
await activeSubstanceDbContext.SaveChangesAsync();
}
}
public async Task <Medicine> CreateMedicine(Medicine medicine, int[] SubstanceIds)
{
using (var medicineDbContext = new MyDataContext())
{
medicineDbContext.Medicines.Add(medicine);
foreach (var item in SubstanceIds)
{
var subtance = await medicineDbContext.ActiveSubstances.Include(i => i.MedicineActiveSubstances).FirstOrDefaultAsync(i => i.Id == item);
var mac = new MedicineActiveSubstance();
mac.Medicine = medicine;
mac.ActiveSubstance = subtance;
subtance.MedicineActiveSubstances.Add(mac);
}
await medicineDbContext.SaveChangesAsync();
return(medicine);
}
}
public async Task CommitAsync()
{
await context.SaveChangesAsync();
}
