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