public void Start(IEventService eventService) { if (eventService == null) { throw new ArgumentNullException(nameof(eventService)); } eventService.AddEvent("InComingToken", "Main", "Main", "InComingToken", EventTypeEnum.before); eventService.AddEvent("InComingHubClientData", "Main", "Main", "InComingHubClientData", EventTypeEnum.before); }
public void AddEventToDatabaseTest() { manager.NukeTheData(); Assert.IsTrue(customerService.AddCustomer(1, "Marek")); Assert.IsTrue(productService.AddProduct(1, "Milk")); Assert.AreEqual(1, productService.GetProductByID(1).ProductID); Assert.AreEqual(1, customerService.GetCustomer(1).CustomerID); Assert.IsTrue(eventService.AddEvent(1, DateTime.Now, productService.GetProductByID(1).ProductID, customerService.GetCustomer(1).CustomerID)); Assert.IsTrue(eventService.DeleteEvent(eventService.GetEventByID(1).EventID)); Assert.IsTrue(productService.DeleteProduct(productService.GetProductByID(1).ProductID)); Assert.IsTrue(customerService.DeleteCustomer(customerService.GetCustomer(1).CustomerID)); }
public IActionResult Create(EventVM vm) { if (ModelState.IsValid) { if (vm.Date < DateTimeOffset.UtcNow) { ModelState.AddModelError("Date", "Invalid Date."); return(View(vm)); } var ev = _mapper.Map <Event>(vm); ev.Date = vm.Date.ToUniversalTime(); _eventService.AddEvent(ev); var ticket = new Ticket() { TicketName = ev.EventName + " Ticket", Description = ev.Description, ExpiryDate = ev.Date.AddDays(1), Quantity = vm.Quantity, EventId = ev.Id }; _ticketService.AddTicket(ticket); return(RedirectToAction("Index", "Home")); } return(View(vm)); }
public async Task <IActionResult> Post([FromBody] EventModel eventModel) { RepeatDays[] repeatDays = eventModel.RepeatDays.Select(o => (RepeatDays)o).ToArray(); RepeatDays? result = null; foreach (RepeatDays f in repeatDays) { result |= (RepeatDays)f; } if (eventModel.Repeat == null || eventModel.Repeat != Repeat.Weekly) { result = null; } Event e = new Event { Id = eventModel.Id, Name = eventModel.Name, Description = eventModel.Description, Location = eventModel.Location, StartDate = eventModel.StartDate == null?dateTimeService.GetCurrentDateTime() : (DateTime)eventModel.StartDate, EndDate = eventModel.EndDate, Repeat = eventModel.Repeat == null ? Repeat.NoRepeat : (Repeat)eventModel.Repeat, RepeatDays = (RepeatDays?)result, Colour = eventModel.Colour, StartTime = eventModel.IsAllDay? "": eventModel.StartTime, EndTime = eventModel.IsAllDay? "" : eventModel.EndTime, IsAllDay = eventModel.IsAllDay }; return(CreatedAtAction("Get", new { id = e.Id }, eventService.AddEvent(e))); }
public async Task <IActionResult> SaveEvent([FromBody] Event evnt) { var response = new SingleModelResponse <Event>() as ISingleModelResponse <Event>; try { if (evnt == null) { throw new Exception("Model is missing"); } response.Model = await Task.Run(() => { Event nevnt = _context.AddEvent(evnt); return(nevnt); }); } catch (Exception ex) { response.DidError = true; response.ErrorMessage = ex.Message; } return(response.ToHttpResponse()); }
public async Task <Event> Post([FromBody] Event evnt) { if (!ModelState.IsValid) { throw new Exception(ModelState.IsValid.ToString()); } var userId = HttpContext.User.GetUserName(); // var user = _userManager. try { var creator = await _userManager.FindByNameAsync(HttpContext.User.GetUserName()); evnt.CreatorId = creator.Id; evnt.CreationDate = DateTime.Now; } catch (Exception e) { Console.WriteLine(e); throw; } return(await _eventService.AddEvent(evnt)); }
public IActionResult AddEvent() { EventModel eventModel = new EventModel(_userManager.GetUserId(this.User), this.User.Identity.Name); int newEventId = _eventService.AddEvent(eventModel); return(RedirectToAction("EditEvent", new { eventId = newEventId })); }
public IActionResult AddEvent([FromBody] Event e) { int.TryParse(User.Identity.Name, out int userId); if (_eventService.AddEvent(e, userId)) { return(Ok(e)); } return(BadRequest("There is something wrong with event info")); }
public IActionResult AddEvent([FromBody] AddEventDto eventDto) { if (!ModelState.IsValid) { return(BadRequest()); } _eventServices.AddEvent(eventDto); return(Ok()); }
public IActionResult AddEvent([FromForm] AddEventDto dto) { if (!_eventService.AddEvent(dto)) { ModelState.AddModelError("Image", "Image's format should be .png or .jpg"); } AddEventViewModel addEventViewModel = _mapper.Map <AddEventViewModel>(dto); return(Ok(addEventViewModel)); }
public string AddEvent([FromBody] Event _event) { if (_eventService.AddEvent(_event)) { return(StatusCodes.Status201Created.ToString()); } else { return(StatusCodes.Status400BadRequest.ToString()); } }
public EventDTO SaveEvent([FromBody] EventDTO eventDTO) { if (eventDTO.Id != 0) { eventService.SaveEvent(eventDTO); return(eventService.GetEvent(eventDTO.Id)); } else { var id = eventService.AddEvent(eventDTO); return(eventService.GetEvent(id)); } }
public IActionResult AddEvent([FromBody] EventViewModel eventViewModel) { _eventService.AddEvent(new Event { Name = eventViewModel.Name, Information = eventViewModel.Information, DateTime = eventViewModel.DateTime, TypeId = eventViewModel.TypeId, PlaceId = eventViewModel.PlaceId }); return(CreateSuccessRequestResult()); }
public ActionResult Create(EventModel model) { try { // TODO: Add insert logic here _eventservice.AddEvent(model); return(RedirectToAction("TournamentEvents", "Tournament", new { TournamentID = Session["TournamentID"] })); } catch { return(View()); } }
private void AddEvent() { bool added = service.AddEvent(EventID, DateTime.Now, ProductID, CustomerID); if (added) { text = "Purchase added"; } else { text = "Cannot add Purchase"; } MessageBoxShowDelegate(Text); }
public IActionResult SaveEvent(EventEditViewModel model, string returnUrl = null) { ViewBag.ReturnUrl = returnUrl; if (model.Date.Date < DateTime.Now.Date) { ModelState.AddModelError("Date", "Please provide an actual date"); } if (string.IsNullOrWhiteSpace(model.Name)) { ModelState.AddModelError("Name", "Name is required"); } if (!ModelState.IsValid) { model = _eventService.ActualizeModel(model); return(View(model.Id.HasValue ? "EditEvent" : "AddEvent", model)); } model.OrganizerId = Guid.Parse(User.FindFirst("userId").Value); var ok = true; if (model.Id.HasValue) { ok = _eventService.UpdateEvent(model); if (ok) { _logger.Here().Information("Event updated: {@Event}", model); } } else { _eventService.AddEvent(model); _logger.Here().Information("New event created: {@Event}", model); } if (!ok) { return(NotFound()); } if (string.IsNullOrEmpty(returnUrl)) { return(RedirectToAction("Events")); } return(Redirect(returnUrl)); }
public IActionResult SaveEvent(Event currentModel, string userId) { if (ModelState.IsValid) { currentModel.UserID = userId; _context.AddEvent(currentModel); _context.SaveEvent(); return(Ok()); } else { return(BadRequest()); } }
public IActionResult AddEvent([FromBody] Event eventObject) { var uniqueCode = GenerateToken(6); while (uniqueCode.Contains("/")) { uniqueCode = GenerateToken(6); } eventObject.UniqueCode = uniqueCode; if (eventObject != null) { _service.AddEvent(eventObject); } return(Ok()); }
public ActionResult AddEvent(ViewEventModel viewEventModel) { if (ModelState.IsValid) { EventModel @event = EventParser.Parse(viewEventModel); @event.UserId = User.Identity.GetUserId(); var eventDTO = Mapper.Map <EventModel, EventDTO>(@event); db.AddEvent(eventDTO); // ParticipantService.AddParticapant(new ParticipantDTO { Email=User.Identity.GetUserName()}) return(RedirectToAction("EventForm")); } else { return(View()); } }
public IActionResult Add(Event e) { var newEvent = new Event { EventName = e.EventName, EventDate = e.EventDate, StartAt = e.StartAt, EndAt = e.EndAt, Location = e.Location }; _eventService.AddEvent(newEvent); _eventService.SaveChanges(); return(RedirectToAction("Invite", "Events", new { id = newEvent.Id })); }
public async Task<IActionResult> AddEvent([FromBody] Event pEvent) { if (pEvent == null) return BadRequest(); try { Event result = await _eventService.AddEvent(pEvent).ConfigureAwait(false); return result == null ? (IActionResult)NoContent() : StatusCode(201, Constant.CreatedSuccessfully); } catch (Exception exception) { _logger.LogError(exception, exception.Message); return StatusCode(StatusCodes.Status500InternalServerError); } }
public async Task <ActionResult <EventDTO> > CreateEvent([FromBody] EventDTO eventDTO) { try { if (eventDTO != null) { eventDTO.OrganizerId = _userService.FindUserByEmail(User.Identity.Name).Id; await _eventService.AddEvent(eventDTO); } return(Ok()); } catch (Exception ex) { return(StatusCode(500, $"Internal server error: {ex}")); } }
public ActionResult Create(EventModel em) { Evenement e = new Evenement { idEvenement = em.idEvenement, nameEvent = em.nameEvent, description = em.description, lieux = em.lieux, dateDebutEvent = em.dateDebutEvent, dateFinEvent = em.dateFinEvent, TypeEvent = em.TypeEvent }; service.AddEvent(e); service.SaveChange(); return(RedirectToAction("Index")); }
public ActionResult Create(EventModel model, bool continueEditing) { if (!model.EndDateEnabled) { model.EndDate = null; } //check there any valid localized models if (ModelState.IsValid && model.CheckLocales()) { if ((ModelState["StartDate"] != null && ModelState["StartDate"].Errors.Count != 0)) { ModelState["Title"].Errors.Clear(); ModelState["ShortDescription"].Errors.Clear(); ModelState["FullDescription"].Errors.Clear(); ViewBag.error = true; return(View(model)); } var evnt = model.ToEntity(); if (!model.EndDateEnabled) { evnt.EndDate = null; } _eventService.AddEvent(evnt); model.SeName = evnt.ValidateSeName(model.SeName, evnt.Title, true); _urlRecordService.SaveSlug(evnt, model.SeName, 0); UpdateLocales(evnt, model); foreach (var loc in model.Locales) { if (loc.Title != null) { loc.SeName = evnt.ValidateSeName(null, loc.Title, true); _urlRecordService.SaveSlug(evnt, loc.SeName, loc.LanguageId); } } //activity log _customerActivityService.InsertActivity("AddNewCategory", "Category added sucesfully", evnt.Title); SuccessNotification("Event Added sucessfully"); return(continueEditing ? RedirectToAction("Edit", new { id = evnt.Id }) : RedirectToAction("List")); } ViewBag.error = true; return(View(model)); }
public IActionResult Add([FromBody] EventViewModel eventViewModel) { try { var email = User.Identity.Name; var user = _context.users.SingleOrDefault(u => u.Email == email); _eventService.AddEvent(eventViewModel, user.UserId); return(Ok()); } catch (ArgumentException ex) { return(BadRequest(ex.Message)); } catch (Exception) { return(StatusCode(StatusCodes.Status500InternalServerError)); } }
public async Task <IActionResult> AddEvent([FromBody] AddEventDTO eventDto) { var createdEvent = await _eventService.AddEvent(eventDto); User usr = await GetCurrentUserAsync(); if (createdEvent != null) { var addEventUser = await _eventService.AddUserToEvent( new JoinEventDTO { EventId = createdEvent.Id, UserId = usr.Id, UserType = "Administrator" }); return(CreatedAtRoute("GetEventById", new { id = createdEvent.Id }, createdEvent)); } return(BadRequest()); }
public async Task <IActionResult> Index([FromForm] EventResource resource) { if (!ModelState.IsValid) { return(BadRequest()); } var claimId = _claimsService.GetUserId(HttpContext.User.Identity as ClaimsIdentity); if (claimId == 0) { return(Unauthorized("You don't have permission to create a place")); } resource.UserId = claimId; var isAdminOfOrganization = await _administratorRepository.IsUserAdministratorOfOrganizator(resource.UserId, resource.OrganizatorId); if (!isAdminOfOrganization) { return(NotFound("You are not an administrator of this organizator")); } var isPlaceExists = await _placeRepository.IsPlaceExistsInOrganizator(resource.OrganizatorId, resource.PlaceId); if (!isPlaceExists) { return(NotFound("Place doesn't exists or is not connected with organizator")); } var isEventDateCollision = _eventRepository.IsEventDateCollision(resource.BeginDate, resource.FinishDate, resource.PlaceId); if (isEventDateCollision) { return(BadRequest("There is other event in this place between your dates")); } await _eventService.AddEvent(resource); return(Ok("Event has been created")); }
public async Task<IActionResult> AddEvent([FromBody] Event eventToAdd, IFormFile file) { var result = _eventValidator.Validate(eventToAdd); if (file != null) { var filename = "wwwroot/uploads/" + Guid.NewGuid() + Path.GetExtension(file.FileName); using (var stream = file.OpenReadStream()) { using(var localStream = new FileStream(filename, FileMode.Create)) { await stream.CopyToAsync(localStream); } } eventToAdd.ImageName = filename; } _eventService.AddEvent(eventToAdd); return Ok(); }
public async Task <IHttpActionResult> Post([FromBody] EventForCreation eventForCreation) { try { await Task.FromResult(0); var ownerId = TokenIdentityHelper.GetOwnerIdFromToken(); if (eventForCreation == null) { return(BadRequest()); } if (ownerId == null) { return(StatusCode(HttpStatusCode.Forbidden)); } // map to entity var @event = Mapper.Map <EventForCreation, Event>(eventForCreation); // create guid var id = Guid.NewGuid(); @event.EventId = id; @event.OwnerId = ownerId; @event.Cars = new Collection <Car>(); var addedEvent = _eventService.AddEvent(@event); // return a dto return(Ok(addedEvent)); } catch (Exception ex) { Log.Logger.Error(ex, "During EventsController.Post"); return(InternalServerError()); } }
public JsonResult CreateEvent(CreateEventModel eventModel) { if (ModelState.IsValid) { var eventDto = (EventDTO) new EventDTO().InjectFrom(eventModel); eventDto.CreatorUserId = Convert.ToInt64(HttpContext.User.FindFirstValue("Id")); eventDto.ImagePath = _eventTypeService.GetImageForEvent(eventModel.EventTypeId); _eventService.AddEvent(eventDto); return(Json(true)); } var errors = new StringBuilder(); foreach (var modelState in ModelState.Select(x => x.Value.Errors).Where(y => y.Count > 0).ToList()) { foreach (var error in modelState) { errors.AppendLine(error.ErrorMessage); } } return(Json(errors.ToString())); }