private async Task <Event> MapNewEvent(CreateEventDto newEventDto) { var newEvent = new Event { Created = DateTime.UtcNow, CreatedBy = newEventDto.UserId, OrganizationId = newEventDto.OrganizationId, OfficeIds = JsonConvert.DeserializeObject <string[]>(newEventDto.Offices.Value), IsPinned = newEventDto.IsPinned }; var newWall = new CreateWallDto { Name = newEventDto.Name, Logo = newEventDto.ImageName, Access = WallAccess.Private, Type = WallType.Events, ModeratorsIds = new List <string> { newEventDto.ResponsibleUserId }, MembersIds = new List <string> { newEventDto.ResponsibleUserId }, UserId = newEventDto.UserId, OrganizationId = newEventDto.OrganizationId }; var wallId = await _wallService.CreateNewWallAsync(newWall); newEvent.WallId = wallId; UpdateEventInfo(newEventDto, newEvent); return(newEvent); }
private void MapNewOptions(CreateEventDto newEventDto, Event newEvent) { if (newEventDto.NewOptions == null) { return; } foreach (var option in newEventDto.NewOptions) { if (option == null) { continue; } var newOption = new EventOption { Created = DateTime.UtcNow, CreatedBy = newEventDto.UserId, Modified = DateTime.UtcNow, ModifiedBy = newEventDto.UserId, Option = option.Option, Rule = option.Rule, Event = newEvent }; _eventOptionsDbSet.Add(newOption); } }
public void Should_Return_MaxChoices_Validation_Exception_While_Creating_Event() { MockUsers(); MockEventTypes(); var newEvent = new CreateEventDto { EndDate = DateTime.UtcNow.AddHours(3), StartDate = DateTime.UtcNow.AddHours(2), Name = "Name", TypeId = 1, ImageName = "qwer", Recurrence = EventRecurrenceOptions.EveryDay, MaxOptions = 0, MaxParticipants = 1, OrganizationId = 1, ResponsibleUserId = "1", Location = "place", NewOptions = new List <NewEventOptionDto> { new NewEventOptionDto { Option = "Type1" }, new NewEventOptionDto { Option = "Type2" } } }; var ex = Assert.ThrowsAsync <EventException>(async() => await _eventService.CreateEventAsync(newEvent)); Assert.That(ex.Message, Is.EqualTo(PremiumErrorCodes.EventNeedToHaveMaxChoiceCode)); }
public async Task <CreateEventDto> CreateEventAsync(CreateEventDto newEventDto) { newEventDto.MaxOptions = FindOutMaxChoices(newEventDto.NewOptions.Count(), newEventDto.MaxOptions); newEventDto.RegistrationDeadlineDate = SetRegistrationDeadline(newEventDto); var hasPermissionToPin = await _permissionService.UserHasPermissionAsync(newEventDto, AdministrationPermissions.Event); _eventValidationService.CheckIfUserHasPermissionToPin(newEventDto.IsPinned, currentPinStatus: false, hasPermissionToPin); _eventValidationService.CheckIfEventStartDateIsExpired(newEventDto.StartDate); _eventValidationService.CheckIfRegistrationDeadlineIsExpired(newEventDto.RegistrationDeadlineDate.Value); await ValidateEvent(newEventDto); _eventValidationService.CheckIfCreatingEventHasInsufficientOptions(newEventDto.MaxOptions, newEventDto.NewOptions.Count()); _eventValidationService.CheckIfCreatingEventHasNoChoices(newEventDto.MaxOptions, newEventDto.NewOptions.Count()); var newEvent = await MapNewEvent(newEventDto); _eventsDbSet.Add(newEvent); MapNewOptions(newEventDto, newEvent); await _uow.SaveChangesAsync(newEventDto.UserId); newEvent.Description = _markdownConverter.ConvertToHtml(newEvent.Description); newEventDto.Id = newEvent.Id.ToString(); return(newEventDto); }
public async Task Should_Return_Created_Event_Without_Options() { MockUsers(); MockEventTypes(); var newEvent = new CreateEventDto { EndDate = DateTime.UtcNow.AddHours(2), StartDate = DateTime.UtcNow.AddHours(1), Name = "Name", TypeId = 1, ImageName = "qwer", Offices = new EventOfficesDto { Value = "[\"1\"]", OfficeNames = new List <string> { "office" } }, Recurrence = EventRecurrenceOptions.EveryDay, MaxOptions = 0, MaxParticipants = 1, OrganizationId = 1, ResponsibleUserId = "1", Location = "place", NewOptions = new List <NewEventOptionDto>() }; await _eventService.CreateEventAsync(newEvent); _eventsDbSet.Received(1).Add(Arg.Any <Event>()); _eventOptionsDbSet.Received(0).Add(Arg.Any <EventOption>()); }
public async Task <Result <EventDto> > Create(CreateEventDto createEventDto, Guid userId) { var category = await Context.Categories.FirstOrDefaultAsync(c => c.Id == createEventDto.CategoryId); if (category == null) { return(Result <EventDto> .Failed(new NotFoundObjectResult(new ApiMessage { Message = ResponseMessage.CategoryNotFound }))); } var host = await Context.Hosts.FirstOrDefaultAsync(c => c.Id == createEventDto.HostId); if (host == null) { return(Result <EventDto> .Failed(new NotFoundObjectResult(new ApiMessage { Message = ResponseMessage.HostNotFound }))); } var user = await Context.Users.FirstOrDefaultAsync(c => c.Id == userId); if (user == null) { return(Result <EventDto> .Failed(new NotFoundObjectResult(new ApiMessage { Message = ResponseMessage.UserNotFound }))); } var newEvent = _mapper.Map <Event>(createEventDto); var dateFromHour = createEventDto.EventSchedule.StartHour; var dateToHour = createEventDto.EventSchedule.EndHour; TimeSpan fromHour; TimeSpan toHour; if (TimeSpan.TryParse(dateFromHour, out fromHour)) { if (TimeSpan.TryParse(dateToHour, out toHour)) { newEvent.EventSchedule.StartHour = fromHour; newEvent.EventSchedule.EndHour = toHour; } } newEvent.EventGallery?.ForEach(e => { e.User = user; e.Id = Guid.NewGuid(); }); await AddAsync(newEvent); await Context.SaveChangesAsync(); return(Result <EventDto> .SuccessFull(_mapper.Map <EventDto>(newEvent))); }
public async Task Should_Return_Created_Event_With_Wall() { MockUsers(); MockEventTypes(); var newEvent = new CreateEventDto { EndDate = DateTime.UtcNow.AddHours(2), StartDate = DateTime.UtcNow.AddHours(1), Name = "Name", TypeId = 1, ImageName = "qwer", Offices = new EventOfficesDto { Value = "[\"1\"]", OfficeNames = new List <string> { "office" } }, Recurrence = EventRecurrenceOptions.EveryDay, MaxOptions = 0, MaxParticipants = 1, OrganizationId = 1, ResponsibleUserId = "1", Location = "place", NewOptions = new List <NewEventOptionDto>() }; await _eventService.CreateEventAsync(newEvent); await _wallService.Received(1) .CreateNewWallAsync(Arg.Is <CreateWallDto>(x => x.Name == newEvent.Name && x.Access == WallAccess.Private && x.Type == WallType.Events && x.ModeratorsIds.Count() == 1 && x.ModeratorsIds.Any(y => y == newEvent.ResponsibleUserId))); }
public CreateEventDto CreateEvent(CreateEventDto eventObj) { var returnObj = new Event() { AssignerId = eventObj.AssignerId, AssignerName = eventObj.AssignerName, Description = eventObj.Description, Start = eventObj.Start, End = eventObj.End, }; _db.Event.Add(returnObj); Save(); foreach (var userId in eventObj.Users) { var eventUsersObj = new EventUsers() { UserId = userId, EventId = returnObj.Id, }; _db.EventUsers.Add(eventUsersObj); } Save(); return(eventObj); }
public async Task <ServiceResponse <EventDto> > Create(CreateEventDto createRequest, string timezone) { var @event = await _eventService.AddEventAsync(_calendarId, new Event { Summary = createRequest.Title, Description = createRequest.Description, Start = new EventDateTime { DateTime = createRequest.Start, TimeZone = timezone }, End = new EventDateTime { DateTime = createRequest.End, TimeZone = timezone } }); if (@event == null) { return(ServiceResponse <EventDto> .Fail); } return(new ServiceResponse <EventDto> { Result = EventsToDto(@event), Success = true }); }
public void Should_Return_Registration_Deadline_Greater_Than_Start_Date_Exception_While_Creating_Event() { MockUsers(); MockEventTypes(); _systemClockMock.UtcNow.Returns(DateTime.Parse("2016-04-05")); var newEvent = new CreateEventDto { EndDate = DateTime.Parse("2016-04-10"), StartDate = DateTime.Parse("2016-04-06"), RegistrationDeadlineDate = DateTime.Parse("2016-04-07"), Name = "Name", TypeId = 1, ImageName = "qwer", Recurrence = EventRecurrenceOptions.EveryDay, MaxOptions = 1, MaxParticipants = 1, OrganizationId = 1, ResponsibleUserId = "1", Location = "place", NewOptions = new List <NewEventOptionDto> { new NewEventOptionDto { Option = "Type1" }, new NewEventOptionDto { Option = "Type2" } } }; var ex = Assert.ThrowsAsync <EventException>(async() => await _eventService.CreateEventAsync(newEvent)); Assert.That(ex.Message, Is.EqualTo(PremiumErrorCodes.EventRegistrationDeadlineGreaterThanStartDateCode)); }
public async Task <IActionResult> CreateEvent([FromBody] CreateEventDto createEventDto) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } var currentUserId = int.Parse(User.FindFirst(ClaimTypes.NameIdentifier).Value); var eventToCreate = new Event { EventName = createEventDto.EventName, EventDescription = createEventDto.EventDescription, EventOwnerId = currentUserId, }; _repo.Add(eventToCreate); if (await _repo.SaveAll()) { return(StatusCode(201)); } throw new Exception("Failed on save."); }
public int Create(CreateEventDto dto) { var events = _mapper.Map <Event>(dto); _dbContext.Events.Add(events); _dbContext.SaveChanges(); return(events.Id); }
public async Task <int> CreateEvent(CreateEventDto createEventDto) { var eventEntity = _mapper.Map <Event>(createEventDto); _context.Events.Add(eventEntity); _context.Save(); return(eventEntity.EventId); }
public async Task <IActionResult> CreateEventAsync([FromBody] CreateEventDto createEventDto) { var eventId = Guid.NewGuid(); await _eventOrganizerService.CreateEventAsync(eventId, UserId, createEventDto); var locationUrl = $"{HttpContext.Request.Scheme}://{HttpContext.Request.Host.ToUriComponent()}/Event/{eventId}"; return(Created(locationUrl, null)); }
public IActionResult CreateEvent([FromBody] CreateEventDto createEventDto) { if (!ModelState.IsValid) { return(BadRequest()); } return(Ok(_eventService.CreateEvent(createEventDto))); }
public async Task CreateAsync(CreateEventDto dto) { if (_settlementRepository.FindByIdAsync(dto.SettlementId) == null) { throw new ResourceNotFoundException(); } var @event = Map <CreateEventDto, Event>(dto); await _eventRepository.CreateAsync(@event); }
public IActionResult CreateEvent([FromBody] CreateEventDto eventObj) { if (eventObj == null) { return(BadRequest(ModelState)); } var objList = _evRepo.CreateEvent(eventObj); return(Ok(objList)); }
public async Task <Dto> CreateEvent <Dto>(CreateEventDto createEventDto) { Event eventEntity = _mapper.Map <Event>(createEventDto); eventEntity.Place = Convert.ToUInt64(new Random().Next(1, 4)); eventEntity = await _repository.Add(eventEntity); Dto mappedEvent = _mapper.Map <Dto>(eventEntity); return(mappedEvent); }
public async Task <IActionResult> UpdateEvent(int eventId, [FromBody] CreateEventDto request) { if (!ModelState.IsValid) { return(BadRequest(ModelState.GetErrorMessages())); } await _eventService.UpdateAsync(eventId, request); return(ApiResponseOk(null)); }
public EventDetailDto Post([FromBody] CreateEventDto eventDto) { var newEvent = _mapper.Map <ScheduledEvent>(eventDto); Request.Headers.TryGetValue("User-Id", out var userId); newEvent.CreatedByUserId = Guid.Parse(userId); var result = _eventsRepo.Add(newEvent); return(_mapper.Map <EventDetailDto>(result)); }
private void FillContext(CreateEventDto dto) { dto.Date = DateTime.UtcNow; dto.MachineName = Environment.MachineName; dto.Username = Environment.UserName; dto.OperatingSystem = EnvironmentHelper.GetOperatinSystemName(); dto.Runtime = EnvironmentHelper.GetRuntimeVersion(); dto.OSArchitecture = EnvironmentHelper.GetOSArchitecture(); dto.Release = Assembly.GetEntryAssembly().GetName().Version.ToString(); dto.Sdk = ClientDefaults.SdkName; dto.SdkVersion = Assembly.GetExecutingAssembly().GetName().Version.ToString(); }
public async Task ReportAsync(string message, EventLevel level) { var dto = new CreateEventDto { Message = message, Level = level, }; FillContext(dto); await ReportEventAsync(dto); }
public async Task <IActionResult> Post([FromBody] CreateEventDto createEventDto) { var user = await _userService.GetById(int.Parse(User.FindFirstValue(ClaimTypes.NameIdentifier))); if (createEventDto.PlannerId != user.PlannerId) { return(BadRequest()); } await _eventService.Create(createEventDto); return(Ok()); }
public async Task UpdateAsync(int eventId, CreateEventDto dto) { var @event = await _eventRepository.FindByIdAsync(eventId); if (@event == null) { throw new ResourceNotFoundException(); } MapToInstance(dto, @event); await _eventRepository.UpdateAsync(@event); }
private async Task ValidateEvent(CreateEventDto eventDto) { var userExists = await _usersDbSet.AnyAsync(u => u.Id == eventDto.ResponsibleUserId); var eventTypeExists = await _eventTypesDbSet.AnyAsync(e => e.Id == eventDto.TypeId); _eventValidationService.CheckIfEndDateIsGreaterThanStartDate(eventDto.StartDate, eventDto.EndDate); // ReSharper disable once PossibleInvalidOperationException _eventValidationService.CheckIfRegistrationDeadlineExceedsStartDate(eventDto.RegistrationDeadlineDate.Value, eventDto.StartDate); _eventValidationService.CheckIfResponsibleUserNotExists(userExists); _eventValidationService.CheckIfOptionsAreDifferent(eventDto.NewOptions); _eventValidationService.CheckIfTypeDoesNotExist(eventTypeExists); }
public async Task <IActionResult> CreateEvent(CreateEventDto input) { try { var eventModel = await _eventAppService.CreateEvent(input); return(Ok(eventModel)); } catch (Exception e) { Console.WriteLine(e); throw; } }
public async Task <OperationResultWithData <MeetingSessionDTO> > CreateEvent([FromBody] CreateEventDto model) { try { LtiParamDTO param = Session.LtiSession.LtiParam; var meetingSessionService = _lmsFactory.GetMeetingSessionService(LmsCompany, param); var eve = await meetingSessionService.CreateSessionAsync(model.MeetingId, param); return(eve.ToSuccessResult()); } catch (Exception ex) { string errorMessage = GetOutputErrorMessage("CreateSession", ex); return(OperationResultWithData <MeetingSessionDTO> .Error(errorMessage)); } }
public EventDto CreateEvent(CreateEventDto addEventDto) { if (!_context.SimpleUsers.Any(x => x.Id == addEventDto.OwnerId)) { return(null); } var @event = _iMapper.Map <Event>(addEventDto); _context.Events.Add(@event); _context.SaveChanges(); var eventDto = _iMapper.Map <EventDto>(@event); return(eventDto); }
private async Task Consumer_Received(object sender, BasicDeliverEventArgs ea) { var body = ea.Body; var message = Encoding.UTF8.GetString(body); var outputQueueMessage = new OutputQueueMessage(); try { CreateEventDto dto = JsonConvert.DeserializeObject <CreateEventDto>(message); outputQueueMessage.Md5 = dto.Md5; using (var scope = _serviceProvider.CreateScope()) { var eventService = scope.ServiceProvider.GetRequiredService <IEventService>(); await eventService.CreateAsync(dto); } outputQueueMessage.EventStatus = EventStatusConstants.SUCCESSFULLY_RECEIVED; } catch (Exception ex) { Console.WriteLine(ex.Message); outputQueueMessage.EventStatus = EventStatusConstants.UNSUCCESSFULLY_RECEIVED; } try { var sended = true; using (var scope = _serviceProvider.CreateScope()) { var queueSenderService = scope.ServiceProvider.GetRequiredService <IQueueSenderService>(); sended = queueSenderService.SendToQueueOutput(outputQueueMessage); } if (outputQueueMessage.EventStatus == EventStatusConstants.SUCCESSFULLY_RECEIVED) { using (var scope = _serviceProvider.CreateScope()) { var eventService = scope.ServiceProvider.GetRequiredService <IEventService>(); await eventService.UpdateSendedToOutputAsync(outputQueueMessage.Md5, sended); } } } catch (Exception ex) { Console.WriteLine(ex.Message); } }
public virtual IActionResult AddEvent([FromBody] CreateEventDto createEventDto) { //TODO: Uncomment the next line to return response 201 or use other options such as return this.NotFound(), return this.BadRequest(..), ... // return StatusCode(201, default(Event)); //TODO: Uncomment the next line to return response 0 or use other options such as return this.NotFound(), return this.BadRequest(..), ... // return StatusCode(0, default(Error)); string exampleJson = null; exampleJson = "null"; var example = exampleJson != null ? JsonConvert.DeserializeObject <Event>(exampleJson) : default(Event); //TODO: Change the data returned return(new ObjectResult(example)); }