public ServiceResponse UpdateEvent(UpdateEventRequest request)
{
var authResponse = _authService.GetCurrentUserId();
if (authResponse.Failure)
{
return(Failure());
}
var updatedEvent = _dataContext
.Events
.Where(e => e.Id == request.Id && e.Habit.UserId == authResponse.Payload)
.FirstOrDefault();
if (updatedEvent == null)
{
return(Failure());
}
updatedEvent.Description = request.Description;
try
{ _dataContext.SaveChanges(); }
catch (Exception)
{ return(Failure()); }
return(Success());
}
public ActionResult <EventsResponse> Update(UpdateEventRequest model)
{
// only admins can update events
if (Account.Role != Role.Admin)
{
return(Unauthorized(new { message = "Unauthorized" }));
}
var calendarEvent = _repository.Event.GetById(model.Id);
// validate
if (_repository.Event.Exists(calendarEvent))
{
throw new AppException($"Event overlaps existing events.");
}
// copy model to account and save
_mapper.Map(model, calendarEvent);
_repository.Event.UpdateEvent(ref calendarEvent, Account.Id);
_logger.LogInfo("Updated event and added to database");
var accountResponse = _mapper.Map <EventsResponse>(calendarEvent);
return(Ok(accountResponse));
}
public async Task <IActionResult> UpdateEvent(int eventId, [FromBody] UpdateEventRequest request)
{
var updateEventCommand = new UpdateEventCommand(eventId, request);
var result = await mediator.Send(updateEventCommand);
return(StatusCode((int)result.Code, result.Value));
}
protected override void ProcessRecord()
{
base.ProcessRecord();
UpdateEventRequest request;
try
{
request = new UpdateEventRequest
{
ManagedInstanceId = ManagedInstanceId,
EventId = EventId,
CompartmentId = CompartmentId,
UpdateEventDetails = UpdateEventDetails,
OpcRequestId = OpcRequestId,
IfMatch = IfMatch
};
response = client.UpdateEvent(request).GetAwaiter().GetResult();
WriteOutput(response, response.Event);
FinishProcessing(response);
}
catch (Exception ex)
{
TerminatingErrorDuringExecution(ex);
}
}
public ActionResult Update(long userId, long id, UpdateEventRequest request)
{
try
{
var foundUser = _serviceUow.UserService.GetUserById(userId);
if (foundUser == null)
{
return(NotFound("User could not be found."));
}
var eventExits = _serviceUow.EventService.IsEventExist(id);
if (!eventExits)
{
return(NotFound("Event could not be found."));
}
var toBeUpdate = Mapper.Map <Event>(request.Event);
var result = _serviceUow.EventService.UpdateEvent(toBeUpdate);
return(Ok(Mapper.Map <EventDTO>(result)));
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
public IActionResult UpdateEvent(long calendarEventId, [FromBody] UpdateEventRequest request)
{
this.eventUpdaterService.UpdateCalendarEvent(
calendarEventId,
request.Summary,
request.Location,
request.StartDate,
request.EndDate);
return(this.Accepted());
}
/// <summary>
/// 更新测试事件
/// </summary>
public async Task <UpdateEventResponse> UpdateEventAsync(UpdateEventRequest updateEventRequest)
{
Dictionary <string, string> urlParam = new Dictionary <string, string>();
urlParam.Add("event_id", updateEventRequest.EventId.ToString());
urlParam.Add("function_urn", updateEventRequest.FunctionUrn.ToString());
string urlPath = HttpUtils.AddUrlPath("/v2/{project_id}/fgs/functions/{function_urn}/events/{event_id}", urlParam);
SdkRequest request = HttpUtils.InitSdkRequest(urlPath, "application/json", updateEventRequest);
HttpResponseMessage response = await DoHttpRequestAsync("PUT", request);
return(JsonUtils.DeSerialize <UpdateEventResponse>(response));
}
public Event UpdateEventRequestToEvent(int eventId, UpdateEventRequest updateEventRequest)
{
return(new Event
{
EventId = eventId,
Name = updateEventRequest.Name,
Date = updateEventRequest.Date,
Description = updateEventRequest.Description,
PlaceId = updateEventRequest.PlaceId,
TypeId = updateEventRequest.TypeId,
});
}
public async Task <IActionResult> UpdateEvent(Guid eventId, [FromBody] UpdateEventRequest request)
{
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
var @event = await EventRepositoryRead.GetById(eventId).ConfigureAwait(false);
if (@event == null)
{
return(NotFound("Event not found with id " + eventId));
}
// TODO: Move this into EventService
@event.Location = request.Location;
@event.Name = request.Name;
@event.OtherDetails = request.OtherDetails;
@event.RsvpOpen = request.RsvpOpen;
@event.TimeZoneId = request.TimeZoneId;
@event.Form.Clear();
foreach (var prompt in request.Form)
{
if (prompt.Id == Guid.Empty)
{
prompt.Id = Guid.NewGuid(); //TODO - move to EventService
}
@event.Form.Add(prompt);
}
if (request.RsvpClosesAtLocal.HasValue)
{
request.RsvpClosesAtLocal.Value.TryConvertToUtc(request.TimeZoneId, out var rsvpClosesAtUtc);
@event.RsvpClosesAtUtc = rsvpClosesAtUtc;
}
else
{
@event.RsvpClosesAtUtc = null;
}
request.StartsAtLocal.TryConvertToUtc(request.TimeZoneId, out var startsAtUtc);
@event.StartsAtUtc = startsAtUtc;
request.EndsAtLocal.TryConvertToUtc(request.TimeZoneId, out var endsAtUtc);
@event.EndsAtUtc = endsAtUtc;
await EventRepositoryWrite.Update(@event).ConfigureAwait(false);
return(Ok(Mapper.MapResponse(@event, DateTimeProvider)));
}
public ModelWithStatus UpdateEvent(UpdateEventRequest request)
{
try
{
string previousTitle = null;
using (DataBaseContext db = new DataBaseContext())
{
var eve = db.Events.First(e => e.ID == request.Id);
previousTitle = eve.Title;
eve.Title = request.Title;
eve.Description = request.Description;
eve.StartTime = DateTime.Parse(request.StartTimeStringUtc, new CultureInfo("en-US"));
eve.EndTime = DateTime.Parse(request.EndTimeStringUtc, new CultureInfo("en-US"));
eve.EventColor = request.EventColor;
db.SaveChanges();
}
//send Push Notification
InvokeAfterSec(1500, () =>
{
using (DataBaseContext db = new DataBaseContext())
{
var users = db.Users.Where(u => !string.IsNullOrEmpty(u.Platform) && !string.IsNullOrEmpty(u.DeviceToken)).ToList();
users = users.Where(u => !u.IsAdmin).ToList();
string alert = string.Empty;
if (string.IsNullOrEmpty(previousTitle))
{
alert = "Hi, The one of the appointment has been updated.";
}
else
{
alert = "Hi, The " + previousTitle + " appointment has been updated.";
}
var pushMessage = new PushMessage()
{
Alert = alert
};
PushNotification(users, pushMessage);
}
});
return(ReturnSuccess());
}
catch (Exception ex)
{
return(ReturnFailed(ex));
}
}
public async Task <bool> UpdateEvent(int eventId, UpdateEventRequest request)
{
var updateEvent = _eventConverter.UpdateEventRequestToEvent(eventId, request);
bool updated;
try
{
updated = await _eventRepository.UpdateEvent(updateEvent);
}
catch
{
throw;
}
return(updated);
}
public Task <EventDTO> UpdateEventAsync(ManageEventDataModel updateEventDataModel, long eventId, CancellationTokenSource cancellationTokenSource) =>
Task <GameDTO> .Run(async() => {
if (!CrossConnectivity.Current.IsConnected)
{
throw new InvalidOperationException(AppConsts.ERROR_INTERNET_CONNECTION);
}
EventDTO updatedEvent = null;
UpdateEventRequest updateEventRequest = new UpdateEventRequest()
{
AccessToken = GlobalSettings.Instance.UserProfile.AccesToken,
Data = updateEventDataModel,
Url = string.Format(GlobalSettings.Instance.Endpoints.ScheduleEndpoints.UpdateEvent, eventId)
};
try {
UpdateEventResponse updateEventResponse = await _requestProvider.PostAsync <UpdateEventRequest, UpdateEventResponse>(updateEventRequest);
if (updateEventResponse != null)
{
updatedEvent = BuildEvent(updateEventResponse);
}
else
{
throw new InvalidOperationException(UPDATE_EVENT_COMMON_ERROR_MESSAGE);
}
}
catch (HttpRequestExceptionEx exc) {
UpdateEventResponse createGameBadResponse = JsonConvert.DeserializeObject <UpdateEventResponse>(exc.Message);
string output = string.Format("{0}",
createGameBadResponse.Errors?.FirstOrDefault());
output = (string.IsNullOrWhiteSpace(output) || string.IsNullOrEmpty(output)) ? UPDATE_EVENT_COMMON_ERROR_MESSAGE : output.Trim();
throw new InvalidOperationException(output);
}
catch (Exception exc) {
Crashes.TrackError(exc);
throw;
}
return(updatedEvent);
}, cancellationTokenSource.Token);
public async Task <IActionResult> Update([FromRoute] Guid eventId, [FromBody] UpdateEventRequest request)
{
var event_ = new Event
{
Id = eventId,
Name = request.Name
};
var updated = await _eventService.UpdateEventAsync(event_);
if (updated)
{
return(Ok(event_));
}
return(NotFound());
}
public ActionResult Update(UpdateEventRequest request)
{
try
{
var id = request.Event.Id;
var found = _serviceUow.EventService.IsEventExist(id);
if (!found)
{
return(NotFound("Event could not be found."));
}
var eventReq = Mapper.Map <EventDTO>(request.Event);
var result = _serviceUow.EventService.UpdateEvent(Mapper.Map <Event>(eventReq));
return(Ok(Mapper.Map <EventDTO>(result)));
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
public async Task <IActionResult> Update([FromRoute] int eventId, [FromBody] UpdateEventRequest request)
{
bool updateEvent;
try
{
updateEvent = await _eventService.UpdateEvent(eventId, request);
}
catch (Exception ex)
{
return(BadRequest(ex));
}
if (updateEvent)
{
return(Ok());
}
return(NotFound());
}
/// <summary>
/// Updates the event.
/// </summary>
/// <param name="eventId">The event identifier.</param>
/// <param name="request">The request.</param>
/// <returns></returns>
public async Task <APIResponse> UpdateEvent(int eventId, UpdateEventRequest request)
{
try
{
string filename = "";
var folderName = Path.Combine("Events");
var pathToSave = Path.Combine("D:", "HappyWedding", folderName);
if (request.CoverPhotos.Length > 0)
{
string format = System.IO.Path.GetExtension(request.CoverPhotos.FileName);
filename = request.VendorId + "_Event_" + DateTime.Now + format;
string filenme = filename.Replace(":", ".");
var filePath = Path.Combine(pathToSave, filenme);
using var fileStream = new FileStream(filePath, FileMode.Create);
request.CoverPhotos.CopyTo(fileStream);
request.CoverPhoto = filePath;
request.CoverPhoto = null;
}
var client = httpClientFactory.CreateClient(VendorServiceOperation.serviceName);
var param = JsonConvert.SerializeObject(request);
HttpContent contentPost = new StringContent(param, Encoding.UTF8, "application/json");
var response = await client.PutAsync(servicesConfig.Vendor +
VendorServiceOperation.UpdateEvent(eventId), contentPost);
if (response.StatusCode == HttpStatusCode.NoContent)
{
}
return(JsonConvert.DeserializeObject <APIResponse>(await response.Content.ReadAsStringAsync()));
}
catch (Exception ex)
{
logger.Error(ex, "Exception in method 'UpdateEvent()'");
var exMessage = ex.InnerException != null ? ex.InnerException.Message : ex.Message;
return(new APIResponse(exMessage, HttpStatusCode.InternalServerError));
}
}
public async Task <Event> UpdateEventAsync(Guid eventId, UpdateEventRequest request)
{
var item = await _context.Events
.Include(e => e.EventPrices)
.Include(e => e.Locations)
.Include(e => e.InstructorForEvents)
.SingleOrThrowAsync(ci => ci.EventId == eventId);
await IsAdminIn(item.ClubId);
item = _mapper.Map(request, item);
_context.Events.Update(item);
//This is simple without validation.
var @event = _mapper.Map <VerifyChangedTimeslotEvent>(item);
@event.RoomIds = request.Locations;
await _eventService.SaveEventAndDbContextChangesAsync(@event);
await _eventService.PublishEventAsync(@event);
return(item);
}
public async Task <IActionResult> UpdateEvent(int eventId, [FromForm] UpdateEventRequest request)
{
var result = await eventService.UpdateEvent(eventId, request);
return(StatusCode((int)result.Code, result.Value));
}
public async Task <IActionResult> UpdateEventDetailsAsync(int yearCourseId, int eventId, UpdateEventRequest request)
{
var apiKey = Request.Headers.FirstOrDefault(h => string.Equals(h.Key, _options.ApiKeyHeaderName, StringComparison.CurrentCultureIgnoreCase))
.Value;
if (yearCourseId != request.YearCourseId)
{
return(BadRequest(new ApiResponse
{
Messages = new List <string>
{
"Year course ID doesn't match!"
}
}));
}
var result = await _mediator.Send(new UpdateEventCommand
{
YearCourseId = request.YearCourseId,
Password = apiKey,
Name = request.Name,
Description = request.Description,
Date = request.Date,
SubjectId = request.SubjectId,
EventTypeId = request.EventTypeId,
Id = request.Id
});
if (!result.Succeeded)
{
return(StatusCode((int?)result.ErrorType ?? 400, new ApiResponse <int>
{
Messages = result.ErrorMessages
}));
}
return(Ok(new ApiResponse()));
}
/// <summary>
/// Initializes a new instance of the <see cref="UpdateMultiCodeCommand" /> class.
/// </summary>
/// <param name="eventId">The multicode identifier.</param>
/// <param name="Request">The request.</param>
public UpdateEventCommand(int eventId, UpdateEventRequest request)
{
Id = eventId;
Request = request;
}
public JsonResult Update([FromBody] UpdateEventRequest request)
{
var response = _eventService.UpdateEvent(request);
return(ServiceResponse(response));
}
public async Task <IActionResult> Update(Guid id, [FromBody] UpdateEventRequest request)
{
var result = await _eventsApi.Update(id, request);
return(Ok(result));
}
