/// <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()));
}
