public bool SaveTimeBooking(TimeBooking timeBooking)
{
if (!ValidateBooking(timeBooking))
{
return(false);
}
TimeBookings.Insert(timeBooking);
if (timeBooking.TimeBookingType == TimeBookingType.Logout)
{
SaveBalance(timeBooking);
}
var date = timeBooking.BookingTime.Date;
var allBookings = TimeBookings.GetDataSinceDayForRefUserId(timeBooking.BookingTime, timeBooking.RefUserId);
while (date.Date < DateTime.Now.Date)
{
var booking = allBookings.SingleOrDefault(x => x.BookingTime.Date == date.Date && x.TimeBookingType == TimeBookingType.Logout);
if (booking != null)
{
SaveBalance(booking);
}
else
{
SaveBalanceWithoutBookings(date, timeBooking.RefUserId);
}
date = date.AddDays(1);
}
return(true);
}
public async Task RegisteredAsync(TimeBooking newBooking)
{
if (OnRegistered != null)
{
await OnRegistered.Invoke(newBooking);
}
}
public IHttpActionResult Post([FromBody] TimeBooking booking)
{
if (!isBookingHaveEverythingExceptUsername(booking))
{
return(BadRequest(ModelState));
}
try
{
if (!String.IsNullOrEmpty(booking.UserName) && HttpContext.Current.User.IsInRole("Admin"))
{
using (var con = new BookingContext())
{
con.Bookings.Add(booking);
con.SaveChanges();
}
}
else
{
using (var con = new BookingContext())
{
booking.UserName = HttpContext.Current.User.Identity.Name;
con.Bookings.Add(booking);
con.SaveChanges();
}
}
}
catch (Exception)
{
return(InternalServerError());
}
MyHub.RequestUpdate();
return(Ok("You have successfully saved the booking."));
}
async Task registerTime()
{
var baseDate = AtDate == DateTime.MinValue ? CurrentDate : AtDate;
var param = new ModalParameters();
var tb = new TimeBooking
{
BookingTime = baseDate.Date.AddHours(DateTime.Now.Hour).AddMinutes(DateTime.Now.Minute)
};
param.Add(nameof(BookTime.Booking2Change), tb);
var ret = Modal.Show <BookTime>("Zeit buchen", param);
var result = await ret.Result;
if (!result.Cancelled)
{
var changed = (TimeBooking)result.Data;
//Context.TimeBookings?.Add(changed);
//await Context.SaveChangesAsync();
await BookingsService.AddBookingAsync(changed);
await AppState.RegisteredAsync(changed);
StateHasChanged();
}
}
public ResourceResponse <Document> Update(TimeBooking value)
{
//Todo: Permissioncheck
//UpdateItems
return(Helper.GetAsyncResult <ResourceResponse <Document> >(DA.UpdateItem(value)));
}
public IActionResult Create([FromRoute] string name, [FromBody] TimeBooking booking)
{
var timesheet = repostitory.GetByName(name);
timesheet.BookTime(booking.Date, booking.Start, booking.Pause, booking.End);
repostitory.Save(timesheet);
return(CreatedAtRoute("GetByDate", new { name = name, date = booking.Date }, timesheet.GetBookingByDate(booking.Date)));
}
private async Task appState_OnRegistered(TimeBooking arg)
{
await InvokeAsync(async() =>
{
TheDate = arg.BookingTime.Date;
await calculateInfo();
await AppState.InfoLoadedFinishedAsync(arg.BookingTime);
StateHasChanged();
});
}
private void CreateNewBooking(TimeBookingType timeBookingType)
{
TimeBooking timeBooking = new TimeBooking();
timeBooking.BookingTime = DateTime.Now;
timeBooking.TimeStamp = DateTime.Now;
timeBooking.TimeBookingType = timeBookingType;
timeBooking.RefUserId = Globals.ActiveUser.UserId;
TimeBookings.Insert(timeBooking);
Validate();
}
private bool isBookingHaveEverythingExceptUsername(TimeBooking bookingToCheck)
{
if (bookingToCheck.To != null && bookingToCheck.From != null && bookingToCheck.Title != null)
{
return(true);
}
else
{
return(false);
}
}
protected override void Seed(TimeBookerApi.Booking.Context.BookingContext context)
{
var booking = new TimeBooking();
booking.From = DateTime.Now;
booking.To = DateTime.Now.AddMinutes(30);
booking.Title = "Möte";
booking.Location = "Mellansel framtidens hus.";
booking.Details = "Möte där vi ska diskutera hanteringen utav ogräs i byns rabatter";
booking.UserName = "******";
context.Bookings.Add(booking);
context.SaveChanges();
}
public async Task AddBookingAsync(TimeBooking newBooking)
{
try
{
_context.TimeBookings?.Add(newBooking);
await _context.SaveChangesAsync();
}
catch (Exception ex)
{
var msg = $"Error adding new time booking for {newBooking.BookingTime.ToShortTimeString()}";
_logger.LogError(ex, msg);
throw new Exception(msg, ex);
}
}
public async Task UpdateBookingAsync(TimeBooking changed)
{
try
{
_context.Update(changed);
await _context.SaveChangesAsync();
}
catch (Exception ex)
{
var msg = $"Error updating booking with new time {changed.BookingTime.ToShortTimeString()}";
_logger.LogError(ex, msg);
throw new Exception(msg, ex);
}
}
public async Task DeleteBookingAsync(TimeBooking booking)
{
try
{
_context.TimeBookings?.Remove(booking);
await _context.SaveChangesAsync();
await _context.SaveChangesAsync();
}
catch (Exception ex)
{
var msg = $"Error deleting booking for time {booking.BookingTime.ToShortTimeString()}";
_logger.LogError(ex, msg);
throw new Exception(msg, ex);
}
}
//protected override async Task OnInitializedAsync()
//{
// await loadData();
//}
public async Task Edit(TimeBooking bTime)
{
var param = new ModalParameters();
param.Add(nameof(BookTime.Booking2Change), bTime);
var ret = Modal.Show <BookTime>("Zeit ändern", param);
var result = await ret.Result;
if (!result.Cancelled)
{
var changed = (TimeBooking)result.Data;
//Context.Update(changed);
//await Context.SaveChangesAsync();
await BookingsService.UpdateBookingAsync(changed);
await AppState.RegisteredAsync(changed);
}
}
public async Task Delete(TimeBooking bTime)
{
var param = new ModalParameters();
param.Add(nameof(Confirm.Message), "Wollen Sie diesen Zeitpunkt wirklich löschen?");
param.Add(nameof(Confirm.OkButtonText), "Löschen");
var ret = Modal.Show <Confirm>("Wirklich löschen", param);
var result = await ret.Result;
if (!result.Cancelled)
{
if ((bool)result.Data == true)
{
await BookingsService.DeleteBookingAsync(bTime);
await AppState.RegisteredAsync(bTime);
}
}
}
public IHttpActionResult Put([FromBody] TimeBooking booking)
{
if (ModelState.IsValid)
{
try
{
using (var con = new BookingContext())
{
var bookingToDelete = con.Bookings.Where(b => b.Id == booking.Id).FirstOrDefault();
var bookingToAdd = new TimeBooking();
if (bookingToDelete != null)
{
con.Bookings.Remove(bookingToDelete);
bookingToAdd.Id = booking.Id;
bookingToAdd.Location = booking.Location;
bookingToAdd.Title = booking.Title;
bookingToAdd.Details = booking.Details;
bookingToAdd.From = booking.From;
bookingToAdd.To = booking.To;
bookingToAdd.UserName = booking.UserName;
con.Bookings.Add(bookingToAdd);
con.SaveChanges();
}
else
{
return(NotFound());
}
}
}
catch (Exception)
{
return(InternalServerError());
}
}
else
{
return(BadRequest(ModelState));
}
MyHub.RequestUpdate();
return(Ok("You have successfully changed the booking."));
}
public bool ValidateBooking(TimeBooking timeBooking)
{
if (timeBooking.RefUserId == 0)
{
return(false);
}
List <TimeBooking> bookingsForSelectedDay = TimeBookings.GetDataForDay(timeBooking.BookingTime, timeBooking.RefUserId);
if (bookingsForSelectedDay?.Count > 0)
{
if (bookingsForSelectedDay.Last().TimeBookingType == timeBooking.TimeBookingType)
{
return(false);
}
if (bookingsForSelectedDay.Last().TimeBookingType == TimeBookingType.Login && (timeBooking.TimeBookingType != TimeBookingType.StartBreak && timeBooking.TimeBookingType != TimeBookingType.Logout))
{
return(false);
}
if (bookingsForSelectedDay.Last().TimeBookingType == TimeBookingType.StartBreak && timeBooking.TimeBookingType != TimeBookingType.EndBreak)
{
return(false);
}
if (bookingsForSelectedDay.Last().TimeBookingType == TimeBookingType.EndBreak && (timeBooking.TimeBookingType != TimeBookingType.StartBreak && timeBooking.TimeBookingType != TimeBookingType.Logout))
{
return(false);
}
}
else
{
if (timeBooking.TimeBookingType != TimeBookingType.Login)
{
return(false);
}
}
return(true);
}
private void SaveBalance(TimeBooking timeBooking)
{
var bookings = TimeBookings.GetDataForDay(timeBooking.BookingTime, timeBooking.RefUserId);
var hours = timeBooking.BookingTime - bookings.First().BookingTime;
var obligatoryHours = TimeObligatoryHours.GetByRefUserId(timeBooking.RefUserId);
if (obligatoryHours.Count > 0)
{
var day = obligatoryHours.SingleOrDefault(x => x.DayOfWeek == timeBooking.BookingTime.DayOfWeek);
if (day != null)
{
var dayItem = CreateDayItem(bookings, day);
var balanceValue = dayItem.WorkingHours.TotalHours - day.HoursPerDay;
var lastItem = TimeBalances.GetLastByDateAndRefUserId(timeBooking.BookingTime, timeBooking.RefUserId);
if (lastItem != null)
{
balanceValue += lastItem.Balance;
}
var existingItem = TimeBalances.GetByDateAndRefUserId(timeBooking.BookingTime, timeBooking.RefUserId);
if (existingItem != null)
{
existingItem.Balance = balanceValue;
TimeBalances.Update(existingItem);
}
else
{
TimeBalance timeBalance = new TimeBalance(timeBooking.RefUserId, timeBooking.BookingTime, balanceValue);
TimeBalances.Insert(timeBalance);
}
}
}
}
public Task <TimeBooking> Update(TimeBooking data)
{
throw new NotImplementedException();
}
public IActionResult UpdateAll([FromRoute] string name, [FromRoute] DateTime date, [FromBody] TimeBooking booking)
{
var timesheet = repostitory.GetByName(name);
timesheet.Update(date, booking);
repostitory.Save(timesheet);
return(Ok(timesheet.GetBookingByDate(date)));
}
public static bool Update(TimeBooking TimeBooking)
{
return(WebApi <bool> .PutAsync(controllerName, TimeBooking, "Put").Result);
}
public static int Insert(TimeBooking TimeBooking)
{
return(WebApi <int> .PostAsync(controllerName, TimeBooking, "SinglePost").Result);
}
public IActionResult Put([FromBody] TimeBooking value)
{
var result = this.DATimeBooking.Update(value);
return(StatusCode((int)result.StatusCode));
}
