public async Task <IHttpActionResult> PutTableAppointment(int id, TableAppointment tableAppointment)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != tableAppointment.AppointmentNo)
{
return(BadRequest());
}
db.Entry(tableAppointment).State = EntityState.Modified;
try
{
await db.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!TableAppointmentExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(StatusCode(HttpStatusCode.NoContent));
}
public async Task <IActionResult> Edit(int id, [Bind("Id,Text,Canceled,Attended,BookedOn,ValidFrom,ValidTo,UserId,EmployeeId")]
TableAppointment tableAppointment)
{
if (id != tableAppointment.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(tableAppointment);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!TableAppointmentExists(tableAppointment.Id))
{
return(NotFound());
}
throw;
}
return(RedirectToAction(nameof(Index)));
}
return(View(tableAppointment));
}
public async Task <IHttpActionResult> GetTableAppointment(int id)
{
TableAppointment tableAppointment = await db.TableAppointments.FindAsync(id);
if (tableAppointment == null)
{
return(NotFound());
}
return(Ok(tableAppointment));
}
public async Task <IHttpActionResult> PostTableAppointment(TableAppointment tableAppointment)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
db.TableAppointments.Add(tableAppointment);
await db.SaveChangesAsync();
return(CreatedAtRoute("DefaultApi", new { id = tableAppointment.AppointmentNo }, tableAppointment));
}
public async Task <IActionResult> Create([Bind("Id,Text,Canceled,Attended,BookedOn,ValidFrom,ValidTo,UserId,EmployeeId")]
TableAppointment tableAppointment)
{
if (ModelState.IsValid)
{
_context.Add(tableAppointment);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(tableAppointment));
}
public async Task <IHttpActionResult> DeleteTableAppointment(int id)
{
TableAppointment tableAppointment = await db.TableAppointments.FindAsync(id);
if (tableAppointment == null)
{
return(NotFound());
}
db.TableAppointments.Remove(tableAppointment);
await db.SaveChangesAsync();
return(Ok(tableAppointment));
}
public async Task <IActionResult> Create([Bind("Id,Text,Canceled,Attended,BookedOn,ValidFrom,ValidTo,UserId,EmployeeId")]
TableAppointment tableAppointment)
{
if (ModelState.IsValid)
{
//_context.Add(tableAppointment);
//await _context.SaveChangesAsync();
//var response = await Sa.SetMeeting(new ExSaveMeetingRequest
// {
// //OptionalText = InfoText,
// //ShopId = _shop.Id,
// //StartTime = Appointment.Meeting.Start,
// //StaffId = Appointment.Meeting.Staff.Id,
// //UserId = 1
// });
return(RedirectToAction(nameof(Index)));
}
return(View(tableAppointment));
}
/// <summary>
/// Termin vereinbaren
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
private async Task <ExSaveDataResult <ExMeeting> > SetMeetingInternal([FromBody] ExSaveMeetingRequest request)
{
using (var db = new Db())
{
var freeEmployeeId = request.StaffId;
if (freeEmployeeId == null)
{
var employees = db.TblLocations
.Include(x => x.TblLocationEmployee)
.Include(x => x.TblLocationEmployee).ThenInclude(x => x.TblEmployee)
.AsNoTracking()
.FirstOrDefault(x => x.Id == request.LocationId)?.TblLocationEmployee;
// TODO Freien Mitarbeiter suchen
var employeesFree = employees?.Where(x => x.TblEmployee.Active);
freeEmployeeId = employeesFree?.FirstOrDefault()?.Id;
}
if (freeEmployeeId == null)
{
return(new ExSaveDataResult <ExMeeting>
{
Description = "Leider wurde kein freier Verkäufer gefunden!",
Caption = "Kein freier Termin",
Result = EnumSaveDataResult.Error,
Data = null,
});
}
// prüfen ob der Mitarbeiter (noch) Zeit hat
var locationEmployee = db.TblEmployees
.Include(x => x.TblVirtualWorkTimes)
.AsNoTracking()
.FirstOrDefault(x => x.Id == freeEmployeeId.Value);
var slotTime = locationEmployee.TblVirtualWorkTimes.FirstOrDefault(x => x.Weekday == request.StartTime.Date.DayOfWeek);
if (slotTime == null)
{
return(new ExSaveDataResult <ExMeeting>
{
Description = "Leider hat der Verkäufer heute frei.",
Caption = "Kein Arbeitstag",
Result = EnumSaveDataResult.Error,
Data = null,
});
}
var meeting = db.TblAppointments.AsNoTracking()
.FirstOrDefault(x => x.EmployeeId == locationEmployee.Id &&
x.ValidTo > request.StartTime &&
x.ValidFrom <= request.StartTime &&
!x.Canceled);
if (meeting != null)
{
return(new ExSaveDataResult <ExMeeting>
{
Description = "Der gewünschte Verkäufer hat zu diesem Zeitpunkt leider bereits einen Termin.",
Caption = "Terminkonflikt",
Result = EnumSaveDataResult.Error,
Data = null,
});
}
var dbMeeting = new TableAppointment
{
UserId = request.UserId,
EmployeeId = freeEmployeeId.Value,
Text = request.OptionalText,
BookedOn = DateTime.UtcNow,
ValidFrom = request.StartTime,
ValidTo = request.StartTime.AddMinutes(slotTime?.TimeSlot ?? 1),
Attended = false,
Canceled = false,
AppointmentDate = request.StartTime.Date,
};
db.TblAppointments.Add(dbMeeting);
try
{
await db.SaveChangesAsync();
}
catch (Exception e)
{
Logging.Log.LogError($"{e}");
return(new ExSaveDataResult <ExMeeting>
{
Description = ExSaveDataResult.GetDefaultSaveError().Description,
Caption = ExSaveDataResult.GetDefaultSaveError().Caption,
Result = EnumSaveDataResult.Error,
Data = null,
});
}
var shop = db.TblLocations
.Include(x => x.Store)
.AsNoTracking()
.FirstOrDefault(x => x.Id == request.LocationId);
var res = new ExSaveDataResult <ExMeeting>
{
Result = EnumSaveDataResult.Ok,
Caption = ExSaveDataResult.GetDefaultSuccess().Caption,
Description = ExSaveDataResult.GetDefaultSuccess().Description,
Data = new ExMeeting
{
Id = dbMeeting.Id,
Start = dbMeeting.ValidFrom,
End = dbMeeting.ValidTo,
ShopId = shop.Id,
ShopName = shop.Store.CompanyName,
Staff = Staff.GetExStaff(db, dbMeeting.EmployeeId),
UserId = dbMeeting.UserId,
}
};
//Shop per E-Mail über neuen Termin informieren
try
{
var meetingInfo = db.TblAppointments
.Include(x => x.Employee)
.Include(x => x.Employee).ThenInclude(x => x.Store)
.Include(x => x.User)
.FirstOrDefault(x => x.Id == dbMeeting.Id);
string shopEMail = meetingInfo.Employee.Store.EMail;
string userName = $"{meetingInfo.User.Firstname} {meetingInfo.User.Lastname}";
string emailContent = $"Neuer Termin mit {(String.IsNullOrEmpty(userName.Trim()) ? "UNBEKANNT" : userName)} am {meetingInfo.ValidFrom.AddHours(2):dd.MM.yyy} um {meetingInfo.ValidFrom.AddHours(2):HH:mm}.";
string email = _mailgenerator.GetMessageOnlyEmail(new ExEMailMessageOnly
{
Message = emailContent
});
BissEMail bm = new BissEMail(WebAppSettings.EmailCredentials);
await bm.SendHtmlEMail(Constants.SendEMailAs, new List <string> {
shopEMail
}, "Neuer Termin", email, Constants.SendEMailAsDisplayName);
}
catch (Exception e)
{
Logging.Log.LogWarning($"E-Mail über neuen Termin konnte nicht gesendet werden: {e}");
throw;
}
return(res);
}
}
