public async Task <IActionResult> CreateEventPost(CreateEventModel createEvent)
{
createEvent.Event.PictureUrl = "http://externalcatalogbaseurltobereplaced/api/pic/100";//"http://localhost:9080/api/pic/100";
await _service.CreateEventAsync(createEvent.Event);
return(View());
}
public async Task <ActionResult> CreateEvent(CreateEventModel model, HttpPostedFileBase file)
{
if (ModelState.IsValid)
{
List <Location> locationList = model.Location;
locationList.RemoveAll(o => o.LocationName.Equals("Remove Location"));
//add location to database
var listLocation = LocationHelpers.Instance.AddNewLocation(locationList);
//Adding new event with given infomation to database
var newEvent = EventDatabaseHelper.Instance.AddNewEvent(model, file, UserHelpers.GetCurrentUser(Session).UserID);
//Add event place to database
var listEventPlaces = EventDatabaseHelper.Instance.AddEventPlace(listLocation, newEvent);
LiveStreamingModel liveModel = new LiveStreamingModel {
eventID = newEvent.EventID, Title = newEvent.EventName
};
TempData["LiveModel"] = liveModel;
HttpCookie newEventID = new HttpCookie("CreateEventID");
newEventID.Value = newEvent.EventID.ToString();
newEventID.Expires = DateTime.Now.AddDays(1);
Response.Cookies.Add(newEventID);
NotificationDataHelpers.Instance.SendNotifyNewEventToFollower(UserHelpers.GetCurrentUser(Session).UserID, newEvent.EventID);
return(RedirectToAction("Details", "Event", new{ id = newEvent.EventID }));
}
// If we got this far, something failed, redisplay form
ViewBag.CategoryID = new SelectList(db.Categories, "CategoryId", "CategoryName");
TempData["errorTitle"] = "Error";
TempData["errorMessage"] = "Please select location from suggestion!";
return(View("Create", model));
}
public int CreateEvent(CreateEventModel model)
{
var userId = GetUserId(model.UserEmail);
try
{
using (var context = new sparrow_dbEntities())
{
var eventModel = new SPRW_ARTIST_EVENT()
{
ACT_IND = true,
ADDRESS = model.Address,
ARTIST_ID = model.ArtistId,
CITY = model.City,
DESCRP = model.Description,
EVENT_DATE = model.EventDate,
LAST_MAINT_TIME = DateTime.Now,
LAST_MAINT_USER_ID = userId,
NAME = model.Name,
STATE = model.State,
URL = model.Url
};
context.SPRW_ARTIST_EVENT.Add(eventModel);
context.SaveChanges();
return(eventModel.EVENT_ID);
}
}
catch (Exception e)
{
throw e;
}
}
public void CreateEvent_Post_ReturnsARedirectAndAddsEvent_WhenModelStateIsValid()
{
// Arrange
var mockRepo = new Mock <IEventRepository>();
mockRepo.Setup(repo => repo.AddEvent(It.IsAny <Event>())).Verifiable();
var @event = new Event()
{
Id = 1, Name = "Test"
};
var createmodel = new CreateEventModel(mockRepo.Object);
createmodel.Event = @event;
// Act
var result = createmodel.OnPost();
// Assert
var redirectToActionResult = Assert.IsType <RedirectToPageResult>(result);
Assert.Equal("Index", redirectToActionResult.PageName);
mockRepo.Verify((e) => e.AddEvent(@event), Times.Once);
}
public void CreateEvent(CreateEventModel model)
{
var newEvent = Event.Create(model.Name);
repository.Add(newEvent);
repository.SaveChanges();
}
public async Task <IViewComponentResult> InvokeAsync()
{
// WARNING: Shitty code
var model = new CreateEventModel
{
EventRepeatModel = new EventRepeatViewModel
{
RepeatOption = EventRepeatOptions.Weekly,
DaysOfTheWeek = new List <DaysOfWeekEnumModel>(),
ExitDate = DateTime.Now.AddYears(1)
}
};
foreach (DayOfWeek day in Enum.GetValues(typeof(DayOfWeek)))
{
model.EventRepeatModel.DaysOfTheWeek
.Add(new DaysOfWeekEnumModel
{
DaysOfWeek = day,
IsSelected = false
});
}
return(View("~/Views/Calendar/_EventRepeatModal.cshtml", model));
}
public async Task <IActionResult> Create(CreateEventModel model)
{
if (ModelState.IsValid)
{
Events even = await db.Events.FirstOrDefaultAsync(u => u.Name == model.Name);
if (even == null)
{
Random rand = new Random();
int i = rand.Next(1, 1000);
db.Events.Add(new Events {
Id = i * 5, Name = model.Name, Type = model.Type, Description = model.Description, Date = model.Date
});
await db.SaveChangesAsync();
return(View("Index", "Events"));
}
else
{
ModelState.AddModelError("", "Something went wrong...");
}
return(View(model));
}
return(View(model));
}
public ActionResult CreateEvent(CreateEventModel createEventObj)
{
Console.WriteLine("SetEvent triggered!");
if (createEventObj.eventID == "NULL" || createEventObj.eventID == "null" || createEventObj.eventID == "Null")
{
return(RedirectToAction("Managment", "Home"));
}
EventModel eventObj = new EventModel();
eventObj.eventID = createEventObj.eventID;
eventObj.startdate = createEventObj.startdate;
eventObj.gender = createEventObj.gender;
eventObj.startdate = createEventObj.startdate;
eventObj.eventtype = createEventObj.eventtype;
Console.WriteLine(eventObj.eventID);
Console.WriteLine(eventObj.startdate);
Console.WriteLine(eventObj.gender);
SqliteDataAccess.SaveEvent(eventObj);
EventJudgeModel eventJudgeObj1 = new EventJudgeModel();
EventJudgeModel eventJudgeObj2 = new EventJudgeModel();
EventJudgeModel eventJudgeObj3 = new EventJudgeModel();
eventJudgeObj1.eventID = createEventObj.eventID;
eventJudgeObj1.judgeID = createEventObj.judge1ID;
eventJudgeObj2.eventID = createEventObj.eventID;
eventJudgeObj2.judgeID = createEventObj.judge2ID;
eventJudgeObj3.eventID = createEventObj.eventID;
eventJudgeObj3.judgeID = createEventObj.judge3ID;
List <EventJudgeModel> eventJudgeObjList = new List <EventJudgeModel>();
eventJudgeObjList.Add(eventJudgeObj1);
eventJudgeObjList.Add(eventJudgeObj2);
eventJudgeObjList.Add(eventJudgeObj3);
foreach (var item in eventJudgeObjList)
{
Console.WriteLine("item: " + item.eventID + " " + item.judgeID);
}
string query = "insert into eventjudge(eventID, judgeID) values(@eventID, @judgeID)";
SqliteDataAccess.SaveManyObjects(eventJudgeObjList, query);
return(RedirectToAction("Managment", "Home"));
}
public async Task <EventModel> CreateEventAsync(
CreateEventModel entity)
{
Event createdEvent = await _repository.CreateEventAsync(
_mapper.Map <Event>(entity));
return(_mapper.Map <EventModel>(createdEvent));
}
public IActionResult CreateEvent(string UserId)
{
CreateEventModel model = new CreateEventModel
{
UserId = UserId
};
return(View(model));
}
public ActionResult AddEvent(CreateEventModel model)
{
SaveEventRequest request = PrepareSaveEventRequest(model);
EventConnection conn = new EventConnection();
conn.SaveEvent(request);
return(RedirectToAction("Home"));
}
public ActionResult Create(CreateEventModel model)
{
if (ModelState.IsValid)
{
service.CreateEvent(model);
return(RedirectToAction("Index"));
}
return(View(model));
}
public static void SetDateOccurrences(CreateEventModel model, ReservationModel reservation)
{
var beginDate = model.EventDate;
var isWeekly = model.EventRepeatModel.RepeatOption == EventRepeatOptions.Weekly;
var isMonthly = model.EventRepeatModel.RepeatOption == EventRepeatOptions.Monthly;
var currentWeek = isWeekly
? GetNextDayOccurence(model.EventDate, DayOfWeek.Monday)
.AddDays((model.EventRepeatModel.RepeatInterval - 1) * 7)
: model.EventDate.AddMonths(model.EventRepeatModel.RepeatInterval);
var lastUpdated = DateTime.MinValue;
var quitDate = model.EventRepeatModel.ExitStrategy == ExitStrategy.FIXED_DATE
? model.EventRepeatModel.ExitDate
: beginDate.AddYears(1);
while (currentWeek < quitDate)
{
var selectedDays = SelectedDays(model.EventRepeatModel.DaysOfTheWeek);
/*
* If its weekly, get next week's monday and add the repeat interval to get next date.
* If its monthly just add one month.
*/
if (isWeekly && currentWeek < lastUpdated.AddDays(model.EventRepeatModel.RepeatInterval * 7 - 7))
{
currentWeek = currentWeek.AddDays(7);
continue;
}
if (isMonthly && currentWeek < lastUpdated.AddMonths(1))
{
currentWeek = currentWeek.AddMonths(1);
continue;
}
foreach (var day in selectedDays)
{
var nextOccurence = GetNextDayOccurence(currentWeek, day);
reservation.EventDates.Add(new EventOccurenceModel
{
Occurence = nextOccurence.AddHours(model.BeginHour.Hour).AddMinutes(model.BeginHour.Minute),
Reservation = reservation,
DurationMinutes = (model.EndHour - model.BeginHour).TotalMinutes
});
currentWeek = nextOccurence;
lastUpdated = nextOccurence;
}
}
}
public async Task <IActionResult> CreateEvent(string UserId, CreateEventModel modelino)
{
if (ModelState.IsValid)
{
await _clubAccess.CreateNewEventAsync(_mapper.Map <CreateEventModelDTO>(modelino));
return(RedirectToAction("MyClub", new { id = UserId }));
}
return(View());
}
public ActionResult Post([FromBody] CreateEventModel model)
{
try
{
var eventEntity = new Event(model.ApplicationId, model.ItemId, model.TriggeredBy, model.Type);
_eventsRepository.Add(eventEntity);
return(Ok());
} catch (Exception ex)
{
return(StatusCode(StatusCodes.Status500InternalServerError));
}
}
public IActionResult CreateEvent()
{
SetRoomsToViewBag();
var model = new CreateEventModel
{
BeginHour = DateTime.Now,
EndHour = DateTime.Now.AddHours(1),
EventDate = DateTime.Now
};
return(View(model));
}
public async Task <IActionResult> CreateEventForm()
{
var vm = new CreateEventModel();
vm.Event = new CatalogEvent();
vm.Types = await _service.GetEventTypesAsync();
vm.Categories = await _service.GetEventCategoriesAsync();
vm.Locations = await _service.GetEventLocationsAsync();
vm.Event.PictureUrl = "http://localhost:9080/api/pic/100";//_picService.GetDefaultImageUrl();//
return(View(vm));
}
public IActionResult AdminEventInfo(int id)
{
Event temp = _clubAccess.GetEventById(id);
CreateEventModel model = new CreateEventModel
{
Description = temp.Description,
EventId = temp.Id,
EventName = temp.EventName,
StartDate = temp.StartDate,
UserId = temp.UserId,
ImagePath = temp.ImagePath
};
return(View(model));
}
public HttpResponseMessage CreateEvent([FromBody] CreateEventModel model)
{
try
{
if (_security.Verify(model.Token, model.UserEmail, model.ArtistId))
{
return(Request.CreateResponse(HttpStatusCode.Created, _artist.CreateEvent(model)));
}
return(Request.CreateResponse(HttpStatusCode.Unauthorized));
}
catch (Exception e)
{
return(Request.CreateResponse(HttpStatusCode.BadRequest));
}
}
public async Task <IActionResult> CreateEvent([FromBody] CreateEventModel model)
{
try
{
var user = await GetLoggedInUser();
await _calendarService.CreateEvent(user.Id.Value, model);
return(Ok());
}
catch (Exception e)
{
return(HandleException(e));
}
}
public IActionResult EventInfo(int id, string UserId)
{
Event temp = _clubAccess.GetEventById(id);
CreateEventModel model = new CreateEventModel
{
Description = temp.Description,
EventId = temp.Id,
EventName = temp.EventName,
StartDate = temp.StartDate,
UserId = temp.UserId,
ImagePath = temp.ImagePath,
NumberOfAttenders = temp.NumberOfAttenders,
IsGoing = _GuestAccess.Followgoingcheck(id, User.FindFirstValue(ClaimTypes.NameIdentifier))
};
return(View(model));
}
public void OnPost_InValidState()
{
// Arrange
var mockRepo = new Mock <IEventRepository>();
var createmodel = new CreateEventModel(mockRepo.Object);
createmodel.ModelState.AddModelError("key1", "The Text field is required.");
// Act
var result = createmodel.OnPost();
// Assert
Assert.IsNotType <PageResult>(result);
var badRequestResult = Assert.IsType <BadRequestObjectResult>(result);
Assert.IsType <SerializableError>(badRequestResult.Value);
}
public ActionResult CreateEvent()
{
ViewBag.Title = "Create Event";
CreateEventModel model = new CreateEventModel();
UniversityConnection conn = new UniversityConnection();
EventConnection econn = new EventConnection();
List <UniversityResponse> response1 = conn.GetAllUniversities();
List <EventCategoryResponse> response2 = econn.GetEventCategories();
List <EventTypeResponse> response3 = econn.GetEventTypes();
model.Universities = ConvertUniversityResponse(response1);
model.EventCategories = ConvertEventCategoryResponse(response2);
model.EventTypes = ConvertEventTypeResponse(response3);
return(View(model));
}
public async Task <int> Post([FromBody] CreateEventModel eventModel)
{
var user = await userManager.GetUserAsync(User);
string ImageURL = string.Empty;
if (ModelState.IsValid && user != null)
{
var venue = await dB.Venues.Where(u => eventModel.VenueId == u.Id).FirstAsync();
var newEvent = new Event(eventModel, user);
newEvent.ImageUrl = string.IsNullOrEmpty(ImageURL) ? "" : ImageURL;
newEvent.Venue = venue;
dB.Events.Add(newEvent);
var result = await dB.SaveChangesAsync();
return(newEvent.Id);
}
return(-1);
}
private SaveEventRequest PrepareSaveEventRequest(CreateEventModel model)
{
string date = model.Date + " " + model.StartTime;
int userId = Convert.ToInt32(Session["UserId"]);
SaveEventRequest request = new SaveEventRequest()
{
Category = model.SelectedCategory,
ContactEmail = model.ContactEmail,
ContactPhone = model.ContactPhone,
Date = date,
Description = model.Description,
EventAdmin = userId,
HostUniversity = model.SelectedUniversity,
Location = 1,
Name = model.Name,
Type = model.SelectedEventType
};
return(request);
}
public async Task <ActionResult> CreateEventAsync(
[FromBody] UpdateEventViewModel entity)
{
var validator = new UpdateEventViewModelValidator(_utilityService, _mapper);
ValidationResult result = validator.Validate(entity);
if (!result.IsValid)
{
return(BadRequest(new ErrorResponseFormat(result.Errors.First().ErrorMessage)));
}
CreateEventModel createEventModel = new CreateEventModel();
_mapper.Map(entity, createEventModel);
createEventModel.CreatorId = new Guid(
User.FindFirst(JwtRegisteredClaimNames.Jti).Value);
var createdEvent = await _service.CreateEventAsync(createEventModel);
return(Ok(_mapper.Map <EventViewModel>(createdEvent)));
}
public async Task <ActionResult <EventModel> > CreateEventAsync(CreateEventModel createEventModel)
{
var eventModel = new EventModel
{
Title = createEventModel.Title,
Description = createEventModel.Description,
StartDate = createEventModel.StartDate,
EndDate = createEventModel.EndDate,
AllDay = createEventModel.AllDay,
Place = createEventModel.Place,
Users = createEventModel.Users.Select(e => new UserModel
{
Id = e.Id,
Username = e.Username
}).ToList()
};
var createdEvent = await _eventService.CreateEventAsync(eventModel);
return(CreatedAtAction(nameof(GetEventAsync), new { id = createdEvent.Id }, createdEvent));
}
public async Task <IActionResult> Put(int id, [FromBody] CreateEventModel modifiedEvent)
{
var item = await dB.Events.FirstOrDefaultAsync(i => i.Id == id);
if (item != null)
{
var venue = await dB.Venues.Where(v => v.Id == modifiedEvent.VenueId).FirstOrDefaultAsync();
var hasAuthorization = await CheckIfHost(item);
if (hasAuthorization)
{
item.Update(modifiedEvent, venue);
dB.Update(item);
var result = await dB.SaveChangesAsync();
return(Ok());
}
return(BadRequest("You do not have authorization to modify"));
}
return(BadRequest("Event not found"));
}
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()));
}
public CreateEventViewModel()
{
Model = new CreateEventModel();
FillTypes();
}
