/// <inheritdoc /> /// <summary> /// Update event /// </summary> /// <param name="evt"></param> /// <param name="evtId"></param> /// <returns></returns> public async Task <ResultModel> UpdateEventAsync(GetEventViewModel evt, string evtId) { var response = new ResultModel(); if (!Authorized || evtId.IsNullOrEmpty()) { return(response); } try { var request = _calendarService.Events.Get(CalendarName, evtId); var googleEvent = await request.ExecuteAsync(); var updateRequest = _calendarService.Events.Update(GoogleCalendarMapper.Map(googleEvent, evt), CalendarName, evtId); await updateRequest.ExecuteAsync(); response.IsSuccess = true; } catch (Exception e) { response.Errors.Add(new ErrorModel(string.Empty, e.Message)); } return(response); }
/// <inheritdoc /> /// <summary> /// Create new event /// </summary> /// <param name="evt"></param> /// <returns></returns> public async Task <ResultModel> PushEventAsync(GetEventViewModel evt) { var response = new ResultModel(); if (!Authorized) { return(response); } var googleEvent = GoogleCalendarMapper.Map(evt); try { var request = _calendarService.Events.Insert(googleEvent, CalendarName); var requestResult = await request.ExecuteAsync(); response.IsSuccess = true; response.Result = requestResult.Id; await _settingsService.SetEventAttributeAsync(evt.Id, $"{nameof(GoogleCalendarProvider)}_evtId", requestResult.Id); } catch (Exception e) { response.Errors.Add(new ErrorModel(e.Message)); } return(response); }
/// <summary> /// Map /// </summary> /// <param name="target"></param> /// <param name="source"></param> /// <returns></returns> public static Event Map(Event target, GetEventViewModel source) { if (target == null || source == null) { return(target); } target.Summary = source.Title; target.Description = source.Details; target.Start = new EventDateTime { DateTime = source.StartDate.AddHours(2) }; target.End = new EventDateTime { DateTime = source.EndDate.AddHours(2) }; target.Location = source.Location; target.Attendees = source.InvitedUsers?.Select(x => new EventAttendee { Email = x.Email }).ToList(); return(target); }
/// <inheritdoc /> /// <summary> /// Push event to outlook calendar /// </summary> /// <param name="evt"></param> /// <returns></returns> public virtual async Task <ResultModel> PushEventAsync(GetEventViewModel evt) { var response = new ResultModel(); if (!_isAuthorized) { return(response); } try { var requestResult = await _graphClient.Me.Events .Request() .Header("Prefer", "outlook.timezone=\"Pacific Standard Time\"") .AddAsync(OutlookMapper.Map(evt)); await _settingsService.SetEventAttributeAsync(evt.Id, $"{nameof(OutlookCalendarProvider)}_evtId", requestResult.Id); response.IsSuccess = true; } catch (Exception e) { Console.WriteLine(e); } return(response); }
/// <summary> /// Map /// </summary> /// <param name="source"></param> /// <param name="target"></param> /// <returns></returns> public static Event Map(Event source, GetEventViewModel target) { if (source == null || target == null) { return(source); } var newEv = Map(target); newEv.Id = source.Id; return(newEv); }
private bool DataValid(GetEventViewModel model) { if (model == default || model.Id < 0 || model.Title == default || model.Description == default || model.EventTypeId == default || model.DeviceIds.Count == 0) { return(false); } return(true); }
/// <summary> /// Map /// </summary> /// <param name="model"></param> /// <returns></returns> public static Event Map(GetEventViewModel model) { if (model == null) { return(new Event()); } var evt = new Event { Summary = model.Title, Description = model.Details, Start = new EventDateTime { DateTime = model.StartDate.AddHours(2), TimeZone = "Europe/Bucharest" }, End = new EventDateTime { DateTime = model.EndDate.AddHours(2), TimeZone = "Europe/Bucharest" }, Organizer = new Event.OrganizerData { DisplayName = model.OrganizerInfo.FirstName + model.OrganizerInfo.LastName, Email = model.OrganizerInfo.Email }, Location = model.Location, Created = model.Created, Attendees = model.InvitedUsers?.Select(x => new EventAttendee { Email = x.Email }).ToList(), Reminders = new Event.RemindersData { UseDefault = false, Overrides = new[] { new EventReminder { Method = "email", Minutes = 10 }, new EventReminder { Method = "sms", Minutes = 10 }, } } }; return(evt); }
/// <inheritdoc /> /// <summary> /// Update event on provider /// </summary> /// <param name="evt"></param> /// <param name="evtId"></param> /// <returns></returns> public virtual async Task <ResultModel> UpdateEventAsync(GetEventViewModel evt, string evtId) { var response = new ResultModel(); if (evtId.IsNullOrEmpty() || !_isAuthorized) { response.Errors.Add(new ErrorModel(string.Empty, "Invalid parameters")); return(response); } try { var outLookEvt = await _graphClient.Me.Events[evtId] .Request() .Header("Prefer", "outlook.timezone=\"Pacific Standard Time\"") .Select(e => new { e.Subject, e.Body, e.BodyPreview, e.Organizer, e.Attendees, e.Start, e.End, e.Location }) .GetAsync(); if (evt == null) { throw new Exception("Event not found"); } await _graphClient.Me.Events[evtId] .Request() .UpdateAsync(OutlookMapper.Map(outLookEvt, evt)); response.IsSuccess = true; } catch (Exception e) { response.Errors.Add(new ErrorModel(string.Empty, e.Message)); } return(response); }
/// <summary> /// Map /// </summary> /// <param name="model"></param> /// <returns></returns> public static Event Map(GetEventViewModel model) { if (model == null) { return(new Event()); } return(new Event { Subject = model.Title, Body = new ItemBody { ContentType = BodyType.Text, Content = model.Details }, Start = new DateTimeTimeZone { DateTime = model.StartDate.ToString("MM/dd/yyyy HH:mm:ss.fff"), TimeZone = "GTB Standard Time" }, End = new DateTimeTimeZone { DateTime = model.EndDate.ToString("MM/dd/yyyy HH:mm:ss.fff"), TimeZone = "GTB Standard Time" }, Location = new Location { DisplayName = model.Location }, Attendees = model.InvitedUsers.Select(x => new Attendee { EmailAddress = new EmailAddress { Address = x.Email, Name = x.FirstName + x.LastName, }, Type = AttendeeType.Required }) }); }
public async Task <CommandResult> ExecuteAsync(GetEventViewModel model) { try { if (!DataValid(model)) { return(CommandResult.Failed(new CommandResultError() { Code = (int)HttpStatusCode.BadRequest, Description = MessageError.SomeDataEmptyOrInvalid })); } var _event = await _eventRepository.Table .Where(n => n.Id == model.Id) .Include(n => n.CategoryIds) .Include(n => n.ProductIds) .Include(n => n.EventDevices) .SingleOrDefaultAsync(); _event ??= new CsmsEvent(); _event.Code = model.Code; _event.StartTime = model.StartTime == default ? _event.StartTime : model.StartTime; _event.EndTime = model.EndTime; _event.StartTimeInDate = model.StartTimeInDate; _event.EndTimeInDate = model.EndTimeInDate; _event.Title = model.Title; _event.Description = model.Description; _event.EventTypeId = model.EventTypeId; _event.DiscountPercent = model.DiscountPercent; _event.MaxDiscount = model.MaxDiscount; _event.MinTotalInvoice = model.MinTotalInvoice; _event.AccountLimit = model.AccountLimit; _event.QuantityLimit = model.QuantityLimit; _event.AppliedAllProducts = model.AppliedAllProducts; _event.Enabled = model.Enabled; _event.ProductIds.Clear(); _event.CategoryIds.Clear(); _event.EventDevices.Clear(); foreach (var catId in model.CategoryIds) { _event.CategoryIds.Add(new CsmsEventCategory() { EventId = model.Id, CategoryId = catId }); } foreach (var productId in model.ProductIds) { _event.ProductIds.Add(new CsmsEventProduct() { EventId = model.Id, ProductId = productId }); } foreach (var deviceId in model.DeviceIds) { _event.EventDevices.Add(new CsmsEventDevice() { EventId = model.Id, DeviceId = deviceId }); } if (_event.Id == default) { await _eventRepository.InsertAsync(_event); var result = await _eventRepository.TableNoTracking .Where(n => n.Id == _event.Id) .Select(n => new EventViewModel() { Id = n.Id, Code = n.Code, Title = n.Title, Description = n.Description, StartDate = n.StartTime, EndDate = n.EndTime, Enabled = n.Enabled, Platforms = n.EventDevices.Select(x => x.Device.Title).ToList() }) .OrderByDescending(n => n.Id) .SingleOrDefaultAsync(); return(CommandResult.SuccessWithData(result)); } else { await _eventRepository.UpdateAsync(_event); var result = await _getEventByIdQuery.ExecuteAsync(_event.Id); return(CommandResult.SuccessWithData(result)); } } catch (Exception) { return(CommandResult.Failed(new CommandResultError() { Code = (int)HttpStatusCode.InternalServerError, Description = MessageError.InternalServerError })); } }
public async Task <IActionResult> SaveEventAsync(GetEventViewModel model) { var result = await _saveEventCommand.ExecuteAsync(model); return(StatusCode(result.GetStatusCode(), result.GetData())); }