public object UpdateEvent([FromBody] CalendarEventModel calendarEventModel)
{
try
{
Calendar calendar = _calendarRepository.UpdateEvent(calendarEventModel.CalendarId,
calendarEventModel.StartTime, calendarEventModel.EndTime, calendarEventModel.Title, calendarEventModel.Notes,
calendarEventModel.Duration, calendarEventModel.Status, 1, true, false, DateTimeOffset.Now);
return(new SingleResponse <CalendarEventModel>
{
Message = string.Empty,
DidError = false,
ErrorMessage = string.Empty,
Token = string.Empty,
Model = calendarEventModel
});
}
catch (Exception ex)
{
return(new SingleResponse <CalendarEventModel>
{
Message = string.Empty,
DidError = true,
ErrorMessage = ex.Message,
Token = string.Empty,
Model = null
});
}
}
public async Task Add_ShouldSendToEndpointAndReturnOk()
{
//Data
var model = new CalendarEventModel
{
Id = Guid.Empty,
Name = "test",
LocationName = "testname",
StartDate = DateTime.Now,
EndDate = DateTime.Now
};
//Setup
_mockEndpointInstance.Setup(x => x.Send(It.Is <AddCalendarEventCommand>(y =>
y.Model.Name == model.Name && y.Model.LocationName == model.LocationName &&
y.Model.StartDate == model.StartDate && y.Model.EndDate == model.EndDate), It.IsAny <SendOptions>()))
.Returns(Task.CompletedTask).Verifiable();
_mockUserManagerWrapper.Setup(x => x.FindByNameAsync(It.IsAny <string>())).Returns(Task.FromResult(new User()));
var calendarController = new CalendarController(_mockEndpointInstance.Object, _mockUserManagerWrapper.Object);
var controllerContext = new ControllerContext
{
HttpContext = _httpContext.Object
};
calendarController.ControllerContext = controllerContext;
//Test
var result = await calendarController.Add(model) as OkResult;
Assert.NotNull(result);
Assert.AreEqual(200, result.StatusCode);
//Analysis
_mockEndpointInstance.Verify();
}
public object DeleteEvent([FromBody] CalendarEventModel calendarEventModel)
{
try
{
Calendar calendar = _calendarRepository.DeleteEvent(calendarEventModel.CalendarId,
calendarEventModel.IsDelete, DateTimeOffset.Now);
return(new SingleResponse <CalendarEventModel>
{
Message = string.Empty,
DidError = false,
ErrorMessage = string.Empty,
Token = string.Empty,
Model = calendarEventModel
});
}
catch (Exception ex)
{
return(new SingleResponse <CalendarEventModel>
{
Message = string.Empty,
DidError = true,
ErrorMessage = ex.Message,
Token = string.Empty,
Model = null
});
}
}
public static void SeedEvents(BackOfficeContext context)
{
if (context.Set <CalendarEventModel>().Any())
{
return; // Db has been seeded;
}
var calendarEvents = new CalendarEventModel[]
{
CreateEvent("#00abff", "Test title event 1", "Test description event 1", new DateTime(2018, 9, 24), new DateTime(2018, 9, 26), CreateReminder(new DateTime(2018, 9, 24, 8, 40, 0), _activeReminder, ReminderTimeOffset.FifteenMinBefore)),
CreateEvent("#00abff", "Test title event 2", "Test description event 2", new DateTime(2018, 9, 27)),
CreateEvent("#00abff", "Test title event 3", "Test description event 3", new DateTime(2018, 9, 25), new DateTime(2018, 9, 30))
};
var todos = new TodoModel[]
{
CreateTodo("Test todo create", false, false),
CreateTodo("Test todo completed", true, false),
CreateTodo("Test todo uncompleted", false, false),
CreateTodo("Test todo archived", true, true),
};
context.Set <CalendarEventModel>().AddRange(calendarEvents);
context.Set <TodoModel>().AddRange(todos);
context.SaveChanges();
}
public async Task <IEnumerable <CalendarEventModel> > GetEvent(CalendarEventModel model)
{
var entities = await _repository.Get(model.Id, model.UserId, model.Name, model.LocationName,
model.StartDate, model.EndDate);
return(Mapper.Map <IEnumerable <CalendarEventModel> >(entities));
}
public async Task HandleGet_ShouldCallGetOnServiceAndReplyOnContext()
{
// Data
var calendarEventModel = new CalendarEventModel {
Name = "test_name"
};
var getCalendarEventCommand = new GetCalendarEventCommand {
Model = calendarEventModel
};
IEnumerable <CalendarEventModel> calendarEvents = new List <CalendarEventModel>
{
calendarEventModel
};
//Setup
_mockCalendarService.Setup(x => x.GetEvent(It.Is <CalendarEventModel>(y => y.Name == getCalendarEventCommand.Model.Name)))
.Returns(Task.FromResult(calendarEvents)).Verifiable();
_mockMessageHandlerContext.Setup(x => x.Reply(It.Is <GetResponse>(y => y.Models == calendarEvents), It.IsAny <ReplyOptions>()))
.Returns(Task.CompletedTask).Verifiable();
//Test
var handler = new CalendarEventHandler(_mockCalendarService.Object);
await handler.Handle(getCalendarEventCommand, _mockMessageHandlerContext.Object);
//Analysis
_mockCalendarService.Verify();
_mockMessageHandlerContext.Verify();
}
public async Task <JsonResult> AddEvent([FromBody] CalendarEventModel clendarEventModel)
{
bool result = true;
string error = string.Empty;
CalendarEventModel calendarEventModel = new CalendarEventModel
{
CalendarId = 0,
DoctorId = clendarEventModel.DoctorId,
PatientId = HttpContext.Session.GetObject(StorageType.UserId).ToString(),//LocalStorageExtensions.Get(StorageType.UserId),
StartTime = clendarEventModel.StartTime,
EndTime = clendarEventModel.EndTime,
Duration = clendarEventModel.Duration,
Title = clendarEventModel.Title,
Notes = clendarEventModel.Notes,
Status = clendarEventModel.Status,
Success = true,
IsDelete = false,
Type = 1,
Timestamp = DateTimeOffset.Now,
};
string response = await APICallerExtensions.APICallAsync("Calendar/AddEvent", calendarEventModel, false, HttpContext.Session.GetObject(StorageType.Token).ToString());
if (string.IsNullOrEmpty(response) || response.ToLower().Contains("exception:"))
{
ModelState.AddModelError(string.Empty, response);
result = false;
error = response;
return(Json(new
{
result,
response
}));
}
var content = JsonConvert.DeserializeObject <SingleResponse <CalendarEventModel> >(response);
if (!content.DidError)
{
return(Json(new
{
content,
result,
error
}));
}
else
{
result = false;
error = response;
return(Json(new
{
result,
error
}));
}
}
internal TimeSlotCalendarEvent(Api api, CalendarEventModel model) : base(api, model)
{
AppointmentGroupId = model.AppointmentGroupId;
AppointmentGroupUrl = model.AppointmentGroupUrl;
CanManageAppointmentGroup = model.CanManageAppointmentGroup;
ReserveUrl = model.ReserveUrl;
Reserved = model.Reserved;
ParticipantsPerAppointment = model.ParticipantsPerAppointment;
Reservations = model.ChildEvents?.Select(m => new UserReservationCalendarEvent(api, m))
?? new List <UserReservationCalendarEvent>();
}
public async Task <IActionResult> Update([FromBody] CalendarEventModel model)
{
var user = await _userManagerWrapper.FindByNameAsync(User.Identity.Name);
model.UserId = user.Id;
var updateCalendarEventCommand = new UpdateCalendarEventCommand {
Model = model
};
await _endpointInstance.Send("LifeManager.Calendar", updateCalendarEventCommand).ConfigureAwait(false);
return(Ok());
}
public static CalendarEventModel ToCalendarEvent(this Appointment appt)
{
var evt = new CalendarEventModel()
{
Description = appt.Description,
EndTime = appt.EndDate,
HasReminder = appt.HasReminder,
Location = appt.Location,
StartTime = appt.StartDate,
Title = appt.Title
};
return(evt);
}
public async Task UpdateEvent_ShouldCallRepositoryUpdate()
{
//Data
var calendarEventModel = new CalendarEventModel();
//Setup
_mockCalendarRepository.Setup(x => x.Update(It.IsAny <CalendarEvent>())).Returns(Task.CompletedTask).Verifiable();
//Test
var calendarService = new CalendarService.Services.CalendarService(_mockCalendarRepository.Object);
await calendarService.UpdateEvent(calendarEventModel);
//Analysis
_mockCalendarRepository.Verify();
}
public async Task <IActionResult> Get([FromBody] CalendarEventModel model)
{
var user = await _userManagerWrapper.FindByNameAsync(User.Identity.Name);
model.UserId = user.Id;
var getCalendarEventCommand = new GetCalendarEventCommand {
Model = model
};
var sendOptions = new SendOptions();
sendOptions.SetDestination("LifeManager.Calendar");
var response = await _endpointInstance.Request <GetResponse>(getCalendarEventCommand, sendOptions).ConfigureAwait(false);
return(Ok(new { Response = response.Models }));
}
public JsonResult SaveEvent(CalendarEventModel calendarEventModel)
{
var status = false;
var processingMessage = this.companySetupService.ProcessCalendarEvent(calendarEventModel);
if (string.IsNullOrEmpty(processingMessage))
{
status = true;
}
return(new JsonResult {
Data = new { status = status }
});
}
public async Task <ActionResult> DeleteAsync(Guid eventId)
{
var meta = await AppUsers.GetCurrentAsync().ConfigureAwait(true);
try
{
await CalendarEventModel.DeleteAsync(this.Tenant, meta, eventId).ConfigureAwait(true);
return(this.Ok());
}
catch (Exception ex)
{
return(this.Failed(ex.Message, HttpStatusCode.InternalServerError));
}
}
public async Task <JsonResult> DeleteEvent([FromBody] CalendarEventModel clendarEventModel)
{
bool result = true;
string error = string.Empty;
CalendarEventModel calendarEventModel = new CalendarEventModel
{
CalendarId = clendarEventModel.CalendarId,
IsDelete = true,
Type = 1,
Timestamp = DateTimeOffset.Now,
};
string response = await APICallerExtensions.APICallAsync("Calendar/DeleteEvent", calendarEventModel, false, HttpContext.Session.GetObject(StorageType.Token).ToString());
if (string.IsNullOrEmpty(response) || response.ToLower().Contains("exception:"))
{
ModelState.AddModelError(string.Empty, response);
result = false;
error = response;
return(Json(new
{
result,
response
}));
}
var content = JsonConvert.DeserializeObject <SingleResponse <CalendarEventModel> >(response);
if (!content.DidError)
{
return(Json(new
{
content,
result,
error
}));
}
else
{
result = false;
error = response;
return(Json(new
{
result,
error
}));
}
}
internal static CalendarEvent FromModel(Api api, CalendarEventModel model)
{
if (model.ReserveUrl != null)
{
return(new TimeSlotCalendarEvent(api, model));
}
if (model.User != null)
{
return(new UserReservationCalendarEvent(api, model));
}
if (model.Type == "event")
{
return(new BasicCalendarEvent(api, model));
}
throw new NotImplementedException("CalendarEvent::FromModel didn't recognize model");
}
public async Task <ActionResult> MyAsync(EventQuery query)
{
if (!this.ModelState.IsValid)
{
return(this.InvalidModelState(this.ModelState));
}
var meta = await AppUsers.GetCurrentAsync().ConfigureAwait(true);
try
{
var model = await CalendarEventModel.GetMyEventsAsync(this.Tenant, query.Start, query.End, meta.UserId, query.CategoryIds).ConfigureAwait(true);
return(this.Ok(model));
}
catch (Exception ex)
{
return(this.Failed(ex.Message, HttpStatusCode.InternalServerError));
}
}
public ActionResult EditEvent(CalendarEventModel newEvent)
{
var calendarEvent = db.CalendarEventModels.ToList().FirstOrDefault(e => e.id == newEvent.id);
if (calendarEvent != null)
{
calendarEvent.allDay = newEvent.allDay;
calendarEvent.start = newEvent.start;
calendarEvent.end = newEvent.end;
try
{
db.SaveChanges();
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
}
return(RedirectToAction("Index"));
}
public void TestCalendarService_GetAll_ShouldCallFindAllRepositoryAndAutoMapper()
{
// Arrange
var expectedRepositoryEvents = new CalendarEventModel[] { };
Mock <IRepository <CalendarEventModel> > calendarEventRepository = new Mock <IRepository <CalendarEventModel> >();
calendarEventRepository.Setup(x => x.FindAll())
.Returns(expectedRepositoryEvents.AsQueryable());
var mapperMock = new Mock <IMapper>();
mapperMock.Setup(m => m.Map <IEnumerable <CalendarEvent> >(It.IsAny <IEnumerable <CalendarEventModel> >()))
.Returns(It.IsAny <IEnumerable <CalendarEvent> >());
var testService = new CalendarService(calendarEventRepository.Object, mapperMock.Object);
// Act
var results = testService.GetAllData();
// Assert
calendarEventRepository.Verify(x => x.FindAll(), Times.Once);
mapperMock.Verify(x => x.Map <IEnumerable <CalendarEvent> >(It.IsAny <IEnumerable <CalendarEventModel> >()), Times.Once);
}
public async Task <ActionResult> PostAsync(CalendarEvent calendarEvent)
{
if (!this.ModelState.IsValid)
{
return(this.InvalidModelState(this.ModelState));
}
var meta = await AppUsers.GetCurrentAsync().ConfigureAwait(true);
calendarEvent.UserId = meta.UserId;
try
{
var eventId = await CalendarEventModel.AddOrEditEntryAsync(this.Tenant, meta, calendarEvent).ConfigureAwait(true);
return(this.Ok(eventId));
}
catch (Exception ex)
{
return(this.Failed(ex.Message, HttpStatusCode.InternalServerError));
}
}
public static CalendarEventModel CreateEvent(
string color,
string title,
string description,
DateTime start,
DateTime?end = null,
ReminderModel reminder = null)
{
var calendarEvent = new CalendarEventModel {
Color = color,
Title = title,
Description = description,
Start = start,
End = end,
Reminders = new List <ReminderModel>()
};
if (reminder != null)
{
calendarEvent.Reminders.Add(reminder);
}
return(calendarEvent);
}
private protected CalendarEvent(Api api, CalendarEventModel model)
{
Api = api;
Id = model.Id;
Title = model.Title;
StartAt = model.StartAt;
EndAt = model.EndAt;
Type = model.Type;
Description = model.Description;
ContextCode = model.ContextCode;
EffectiveContextCode = model.EffectiveContextCode;
AllContextCodes = model.AllContextCodes.Split(',');
WorkflowState = model.WorkflowState;
Hidden = model.Hidden;
ParentEventId = model.ParentEventId;
ChildEvents = model.ChildEvents.SelectNotNull(child => FromModel(api, child));
ChildEventsCount = model.ChildEventsCount;
Url = model.Url;
HtmlUrl = model.HtmlUrl;
AllDayDate = model.AllDayDate;
AllDay = model.AllDay;
CreatedAt = model.CreatedAt;
UpdatedAt = model.UpdatedAt;
}
public ActionResult AddEvent(CalendarEventViewModel newEvent)
{
try
{
CalendarEventModel calendarEvent = new CalendarEventModel
{
title = newEvent.title,
color = Enum.GetName(typeof(eventColor), newEvent.color),
description = newEvent.description,
start = newEvent.startDate.Date.ToString("yyyy-MM-dd") + "T" + newEvent.startTime + ":00",
allDay = newEvent.allDay
};
if (!calendarEvent.allDay)
{
calendarEvent.end = newEvent.endDate + "T" + newEvent.endTime + ":00";
}
else
{
calendarEvent.end = null;
}
try
{
db.CalendarEventModels.Add(calendarEvent);
db.SaveChanges();
}
catch (Exception e) {
Console.WriteLine(e.Message);
}
return(RedirectToAction("Index"));
}
catch (Exception e)
{
Console.WriteLine(e.Message);
return(View());
}
}
public async Task GetEvent_ShouldReturnEvent()
{
//Data
var calendarEventModel = new CalendarEventModel();
IEnumerable <CalendarEvent> calendarEvents = new[]
{
new CalendarEvent {
Id = calendarEventModel.Id
}
}.ToList();
//Setup
_mockCalendarRepository.Setup(x => x.Get(calendarEventModel.Id, calendarEventModel.UserId, null, null, It.IsAny <DateTime>(), It.IsAny <DateTime>()))
.Returns(Task.FromResult(calendarEvents)).Verifiable();
//Test
var calendarService = new CalendarService.Services.CalendarService(_mockCalendarRepository.Object);
var result = await calendarService.GetEvent(calendarEventModel);
//Analysis
Assert.AreEqual(1, result.Count());
Assert.AreEqual(calendarEventModel.Id, result.First().Id);
_mockCalendarRepository.Verify();
}
public void TestCalendarService_GetById_ShouldCallFindRepositoryAndAutoMapper()
{
// Arrange
var expectedRepositoryEvents = new CalendarEventModel[] { };
// mock repository
Mock <IRepository <CalendarEventModel> > calendarEventRepository = new Mock <IRepository <CalendarEventModel> >();
calendarEventRepository.Setup(repo => repo.Find(It.IsAny <Expression <Func <CalendarEventModel, bool> > >()))
.Returns(expectedRepositoryEvents.AsQueryable());
// mock automapper
var mapperMock = new Mock <IMapper>();
mapperMock.Setup(m => m.Map <CalendarEvent>(It.IsAny <CalendarEventModel>()))
.Returns(It.IsAny <CalendarEvent>());
var calendarService = new CalendarService(calendarEventRepository.Object, mapperMock.Object);
// Act
var result = calendarService.GetById(1);
// Assert
calendarEventRepository.Verify(x => x.Find(It.IsAny <Expression <Func <CalendarEventModel, bool> > >()), Times.Once);
mapperMock.Verify(x => x.Map <CalendarEvent>(It.IsAny <CalendarEventModel>()), Times.Once);
}
public ActionResult EditEvent(CalendarEventModel model)
{
string ServerName = AppValue.GetFromMailAddress("ServerName");
var varUpdateEvents = objdb.CalenderEvents.Where(t => t.EventID == model.EventId).Select(e => e).FirstOrDefault();
varUpdateEvents.EventName = model.EventName;
varUpdateEvents.EventDescription = model.EventDescription;
varUpdateEvents.StartDate = model.StartDate;
varUpdateEvents.Enddate = model.EndDate;
varUpdateEvents.StartTime = model.StartTime;
varUpdateEvents.EndTime = model.EndTime;
varUpdateEvents.ColorCode = model.ColorCode;
objdb.SaveChanges();
var dbEventUsers =
objdb.CalendarEventUserMappings.Where(c => c.EventID == model.EventId).Select(ce => ce).ToList();
List <int?> modelMemberList = new List <int?>();
string[] members = model.Members.Split(',');
for (int i = 0; i < members.Count(); i++)
{
modelMemberList.Add(Convert.ToInt32(members[i]));
}
var insertUser = modelMemberList.Where(u => dbEventUsers.All(r => r.UserId != u.Value));
var deleteUser = dbEventUsers.Where(u => modelMemberList.All(r => r.Value != u.UserId));
var useInsertUser = insertUser.Select(i => i.Value).ToList();
var useDeleteUser = deleteUser.Select(d => d.UserId).ToList();
foreach (var users in useInsertUser)
{
var varInsertUser = objdb.CalendarEventUserMappings.CreateObject();
varInsertUser.EventID = model.EventId;
varInsertUser.UserId = users;
objdb.CalendarEventUserMappings.AddObject(varInsertUser);
objdb.SaveChanges();
}
foreach (var users in useDeleteUser)
{
var varDeleteUser =
objdb.CalendarEventUserMappings.Where(c => c.UserId == users && c.EventID == model.EventId).FirstOrDefault();
objdb.CalendarEventUserMappings.DeleteObject(varDeleteUser);
objdb.SaveChanges();
}
List <string> membersmailids = new List <string>();
foreach (int item in modelMemberList)
{
var username = objdb.Users.Where(x => x.UserID == item).Select(o => o.UserName).FirstOrDefault();
membersmailids.Add(username);
}
DSRCManagementSystemEntities1 db = new DSRCManagementSystemEntities1();
var objcom = db.Master_ApplicationSettings.Where(x => x.AppKey == "Company Name").Select(o => o.AppValue).FirstOrDefault();
string Title = " " + objcom + " calendar event updated";
string Subject = " event was updated on " + DateTime.Today.ToString("dd MMM yyyy");
var check = db.EmailTemplates.Where(x => x.TemplatePurpose == "Edit Event").Select(o => o.EmailTemplateID).FirstOrDefault();
var folder = db.EmailTemplates.Where(o => o.TemplatePurpose == "Edit Event").Select(x => x.TemplatePath).FirstOrDefault();
if ((check != null) && (check != 0))
{
var obj = (from p in db.EmailPurposes.Where(x => x.EmailPurposeName == "Edit Event")
join q in db.EmailTemplates on p.EmailTemplateID equals q.EmailTemplateID
select new DSRCManagementSystem.Models.Email
{
To = p.To,
CC = p.CC,
BCC = p.BCC,
Subject = p.Subject,
Template = q.TemplatePath
}).FirstOrDefault();
string TemplatePath = Server.MapPath(obj.Template);
string html = System.IO.File.ReadAllText(TemplatePath);
Title = " " + objcom + " calendar event updated";
Subject = " event has changed , please refer the below details";
obj.Subject = " " + objcom + " Management Portal event Updated";
html = html.Replace("#Title", Title);
html = html.Replace("#Subject", Subject);
html = html.Replace("#EventName", model.EventName);
html = html.Replace("#EventDescription", model.EventDescription);
html = html.Replace("#StartDate", model.StartDate.ToString());
html = html.Replace("#EndDate", model.EndDate.ToString());
html = html.Replace("#CompanyName", objcom.ToString());
html = html.Replace("#ServerName", ServerName);
obj.To = MyCalendarController.GetUserEmailAddress(db, obj.To);
obj.CC = MyCalendarController.GetUserEmailAddress(db, obj.CC);
if (obj.BCC != "")
{
obj.BCC = MyCalendarController.GetUserEmailAddress(db, obj.BCC);
}
//string ServerName1 = WebConfigurationManager.AppSettings["SeverName"];
if (ServerName != "http://*****:*****@dsrc.co.in");
//MailIds.Add("*****@*****.**");
//MailIds.Add("*****@*****.**");
//MailIds.Add("*****@*****.**");
//MailIds.Add("*****@*****.**");
//MailIds.Add("*****@*****.**");
//MailIds.Add("*****@*****.**");
//foreach (var item in membersmailids)
//{
// MailIds.Add(item.ToString());
//}
string EmailAddress = "";
foreach (string maiil in MailIds)
{
EmailAddress += maiil + ",";
}
EmailAddress = EmailAddress.Remove(EmailAddress.Length - 1);
string CCMailId = "*****@*****.**";
string BCCMailId = "*****@*****.**";
Task.Factory.StartNew(() =>
{
//var logo = db.Master_ApplicationSettings.Where(x => x.AppID == 7).Select(x => x).FirstOrDefault();
//string[] words;
//words = logo.AppValue.Split(new string[] { "../../" }, StringSplitOptions.None);
//string pathvalue = "~/" + words[1];
string pathvalue = CommonLogic.getLogoPath();
DsrcMailSystem.MailSender.SendMailToALL(null, obj.Subject + " - Test Mail Please Ignore", null, html + " - Testing Plaese ignore", "*****@*****.**", EmailAddress, CCMailId, BCCMailId, Server.MapPath(pathvalue.ToString()));
});
}
else
{
Task.Factory.StartNew(() =>
{
//var logo = db.Master_ApplicationSettings.Where(x => x.AppID == 7).Select(x => x).FirstOrDefault();
//string[] words;
//words = logo.AppValue.Split(new string[] { "../../" }, StringSplitOptions.None);
//string pathvalue = "~/" + words[1];
string pathvalue = CommonLogic.getLogoPath();
DsrcMailSystem.MailSender.SendMailToALL(null, obj.Subject, "", html, "*****@*****.**", obj.To, obj.CC, obj.BCC, Server.MapPath(pathvalue.ToString()));
});
}
}
else
{
// string ServerName = WebConfigurationManager.AppSettings["SeverName"];
ExceptionHandlingController.TemplateMissing("Edit Event", folder, ServerName);
}
return(Json("Success", JsonRequestBehavior.AllowGet));
}
internal UserReservationCalendarEvent(Api api, CalendarEventModel model) : base(api, model)
{
AppointmentGroupId = model.AppointmentGroupId;
AppointmentGroupUrl = model.AppointmentGroupUrl;
User = model.User.ConvertIfNotNull(m => new User(api, m));
}
internal BasicCalendarEvent(Api api, CalendarEventModel model) : base(api, model)
{
LocationName = model.LocationName;
LocationAddress = model.LocationAddress;
}
public async Task CreateEvent(CalendarEventModel model)
{
model.Id = Guid.NewGuid();
var calendarEvent = Mapper.Map <CalendarEvent>(model);
await _repository.Add(calendarEvent);
}
public async Task UpdateEvent(CalendarEventModel model)
{
var calendarEvent = Mapper.Map <CalendarEvent>(model);
await _repository.Update(calendarEvent);
}
