public IActionResult Create(EventBindingModel model)
{
var oracle = _eventService.GetSender();
var result = _eventService.Deploy(oracle, model.HomeTeamName, model.AwayTeamName);
if (result.Success == false)
{
this.ViewBag.ErrorMessage = "Deploy event failed";
_logger.LogCritical($"Deploy event failed {result.GetListMessages()}");
return(this.View("Index"));
}
var info = _eventService.GetEventInfo(result.Value);
if (info.Success == false)
{
this.ViewBag.ErrorMessage = "Getting event info failed";
_logger.LogCritical($"GetEventInfo failed {info.GetListMessages()}");
return(this.View("Index"));
}
var dto = new Event()
{
Address = result.Value,
AwayTeamName = info.Value.AwayTeamName,
HomeTeamName = info.Value.HomeTeamName,
IsOpen = info.Value.IsOpen,
ExpireAt = DateTimeExtensions.UnixTimeStampToDateTime(info.Value.ExpireAt),
};
this.DbContext.Events.Add(dto);
this.DbContext.SaveChanges();
return(this.RedirectToAction("ViewAll"));
}
private void AttachUsersToPositions(Event dbEvent, EventBindingModel model)
{
foreach (var position in model.Positions)
{
var dbPosition = dbEvent.Positions.FirstOrDefault(p => p.PositionId == position.Id);
if (dbPosition != null && dbPosition.Position.EventAttendees.Count != 0)
{
string aproovedPlayerId = dbPosition.Position.EventAttendees.First().UserId;
position.Approved.Name = userManager.Users.FirstOrDefault(u => u.Id == aproovedPlayerId).UserName;
position.Approved.Id = aproovedPlayerId;
position.Approved.EventId = dbEvent.Id;
position.Approved.PositionId = position.Id;
}
if (dbPosition != null && dbPosition.Position.EventAttendeesToBeApproved.Count != 0)
{
var toBeAprooved = dbPosition.Position.EventAttendeesToBeApproved.ToList();
foreach (var user in toBeAprooved)
{
PlayerModel pendingAproval = new PlayerModel();
pendingAproval.Name = userManager.Users.FirstOrDefault(u => u.Id == user.UserId).UserName;
pendingAproval.Id = user.UserId;
pendingAproval.EventId = dbEvent.Id;
pendingAproval.PositionId = position.Id;
position.ToBeApproved.Add(pendingAproval);
}
}
}
}
public async Task <Guid> CreateEvent(EventBindingModel model)
{
IUser account = await this._userManager.FindByIdAsync(User.Identity.GetUserId());
CreateEventResponse response = await this._eventsService.CreateEvent(new CreateEventRequest
{
AccountId = Guid.Parse(account.Id),
AlgorithmType = model.AlgorithmType,
CloseDate = model.CloseDate,
CurrencyType = model.CurrencyType,
EndDate = model.EndDate,
EndRate = model.EndRate,
EventRelationType = model.EventRelationType,
ExpectedEventCondition = model.ExpectedEventCondition,
ImageUri = model.ImageUri,
ArbiterAccountIds = (await this.MatchesAccounts(model.ArbiterAccounts)).Select(a => Guid.Parse(a.Id)),
LocusRage = model.LocusRage,
ParticipantsAccountIds = (await this.MatchesAccounts(model.ParticipantsAccounts)).Select(a => Guid.Parse(a.Id)),
StartDate = model.StartDate,
StartRate = model.StartRate,
Title = model.Title
});
return(response.EventId);
}
public void Test_Put_UnauthorizedUser()
{
// Arrange: set UserMaria as currently logged in user
TestingUtils.AssignCurrentUserForController(
this.eventsController, this.testDb.UserMaria);
// Get the "OpenFest" event with owner GuestUser
var openFestEvent = this.testDb.EventOpenFest;
// Create an event binding model
var changedEvent = new EventBindingModel();;
// Act: invoke the controller method with invalid id and cast the result
var result = this.eventsController
.PutEvent(openFestEvent.Id, changedEvent) as UnauthorizedObjectResult;
Assert.IsNotNull(result);
// Assert an "Unauthorized" result with an error message is returned
Assert.AreEqual((int)HttpStatusCode.Unauthorized, result.StatusCode);
var resultValue = result.Value as ResponseMsg;
Assert.AreEqual($"Cannot edit event, when not an owner.", resultValue.Message);
}
public void Test_Edit_PostInvalidData()
{
// Arrange: get the "Dev Conference" event from the database for editing
var devConfEvent = this.testDb.EventDevConf;
// Create an event binding model with invalid name: name == empty string
var invalidName = string.Empty;
EventBindingModel model = new EventBindingModel()
{
Name = invalidName,
Place = devConfEvent.Place,
Start = devConfEvent.Start,
End = devConfEvent.End,
TotalTickets = devConfEvent.TotalTickets,
PricePerTicket = devConfEvent.PricePerTicket
};
// Add error to the controller
this.controller.ModelState.AddModelError("Name", "The Name field is required");
// Act: invoke the controller method
var result = this.controller.Edit(devConfEvent.Id, model);
// Assert the user is not redirected
var redirectResult = result as RedirectToActionResult;
Assert.IsNull(redirectResult);
// Assert the event's name is not edited
var editedEvent = this.dbContext.Events.Find(devConfEvent.Id);
Assert.IsNotNull(editedEvent);
Assert.AreEqual(devConfEvent.Name, editedEvent.Name);
// Remove ModelState error for next tests
this.controller.ModelState.Remove("Name");
}
public ActionResult Edit(int id, EventBindingModel model)
{
var eventToEdit = this.EventLoad(id);
if (eventToEdit == null)
{
this.AddNotification("Cannot edit event #" + id, NotificationType.ERROR);
return(this.RedirectToAction("My"));
}
if (model != null && this.ModelState.IsValid)
{
eventToEdit.Title = model.Title;
eventToEdit.StartDateTime = model.StartDateTime;
eventToEdit.Duration = model.Duration;
eventToEdit.Description = model.Description;
eventToEdit.Location = model.Location;
eventToEdit.IsPublic = model.IsPublic;
this.db.SaveChanges();
this.AddNotification("Event edited.", NotificationType.INFO);
return(this.RedirectToAction("My"));
}
return(this.View(model));
}
public IActionResult Edit(int id, EventBindingModel bindingModel)
{
Event ev = this.dbContext.Events.Find(id);
if (ev == null)
{
// When event with this id doesn't exist
return(BadRequest());
}
string currentUserId = GetUserId();
if (currentUserId != ev.OwnerId)
{
// Not an owner -> return "Unauthorized"
return(Unauthorized());
}
if (!this.ModelState.IsValid)
{
return(View(bindingModel));
}
ev.Name = bindingModel.Name;
ev.Place = bindingModel.Place;
ev.Start = bindingModel.Start;
ev.End = bindingModel.End;
ev.TotalTickets = bindingModel.TotalTickets;
ev.PricePerTicket = bindingModel.PricePerTicket;
this.dbContext.SaveChanges();
return(RedirectToAction("All"));
}
public IActionResult Edit(int id)
{
Event ev = this.dbContext.Events.Find(id);
if (ev == null)
{
// When event with this id doesn't exist
return(BadRequest());
}
string currentUserId = GetUserId();
if (currentUserId != ev.OwnerId)
{
// When current user is not an owner
return(Unauthorized());
}
EventBindingModel model = new EventBindingModel()
{
Name = ev.Name,
Place = ev.Place,
Start = ev.Start,
End = ev.End,
PricePerTicket = ev.PricePerTicket,
TotalTickets = ev.TotalTickets
};
return(View(model));
}
public async Task Test_Events_EditEvent_InvalidData()
{
// Arrange: get the "Dev Conference" event
var devConfEvent = this.testDb.EventDevConf;
// Create new event binding model, where only the event name is changed
// The name is invalid
var changedName = string.Empty;
var changedEvent = new EventBindingModel()
{
Name = changedName,
Place = devConfEvent.Place,
Start = devConfEvent.Start,
End = devConfEvent.End,
TotalTickets = devConfEvent.TotalTickets,
PricePerTicket = devConfEvent.PricePerTicket
};
// Act: send PUT request with the changed event
var putResponse = await this.httpClient.PutAsJsonAsync(
$"/api/events/{devConfEvent.Id}", changedEvent);
// Assert "BadRequest" is returned
Assert.AreEqual(HttpStatusCode.BadRequest, putResponse.StatusCode);
// Assert the event in not edited in the database
this.dbContext = this.testDb.CreateDbContext();
var eventInDbAfter = this.dbContext.Events.Find(devConfEvent.Id);
Assert.AreEqual(devConfEvent.Name, eventInDbAfter.Name);
}
public async Task Test_Events_CreateEvent_ValidData()
{
// Arrange: create a new binding model
var eventName = "Party";
var eventPlace = "Beach";
var newEvent = new EventBindingModel()
{
Name = eventName,
Place = eventPlace,
Start = DateTime.Now.AddDays(1),
End = DateTime.Now.AddDays(2),
TotalTickets = 120,
PricePerTicket = 20.00M
};
var eventsCountBefore = this.dbContext.Events.Count();
// Act: send a POST request with the new event binding model
var postResponse = await this.httpClient.PostAsJsonAsync(
"/api/events/create", newEvent);
// Assert the event is created successfully
Assert.AreEqual(HttpStatusCode.Created, postResponse.StatusCode);
this.dbContext = this.testDb.CreateDbContext();
var eventsCountAfter = this.dbContext.Events.Count();
Assert.AreEqual(eventsCountBefore + 1, eventsCountAfter);
}
public async Task Test_Events_EditEvent_ValidId()
{
// Arrange: get the "Dev Conference" event
var devConfEvent = this.testDb.EventDevConf;
// Create new event binding model, where only the event name is changed
var changedName = "Dev Conference (New Edition)";
var changedEvent = new EventBindingModel()
{
Name = changedName,
Place = devConfEvent.Place,
Start = devConfEvent.Start,
End = devConfEvent.End,
TotalTickets = devConfEvent.TotalTickets,
PricePerTicket = devConfEvent.PricePerTicket
};
// Act: send PUT request with the changed event
var putResponse = await this.httpClient.PutAsJsonAsync(
$"/api/events/{devConfEvent.Id}", changedEvent);
// Assert
Assert.AreEqual(HttpStatusCode.NoContent, putResponse.StatusCode);
this.dbContext = this.testDb.CreateDbContext();
var eventInDbAfter = this.dbContext.Events.Find(devConfEvent.Id);
Assert.AreEqual(changedName, eventInDbAfter.Name);
}
public async Task Test_Events_EditEvent_InvalidId()
{
// Arrange: create an event binding model with changed name
var changedName = "Dev Conference (New Edition)";
var changedEvent = new EventBindingModel()
{
Name = changedName,
Place = "Sofia",
Start = DateTime.Now.AddMonths(3),
End = DateTime.Now.AddMonths(3),
TotalTickets = 200,
PricePerTicket = 12.00m
};
var invalidId = -1;
// Act: send a PUT request with invalid id
var putResponse = await this.httpClient.PutAsJsonAsync(
$"/api/events/{invalidId}", changedEvent);
// Assert "NotFound" is returned
Assert.AreEqual(HttpStatusCode.NotFound, putResponse.StatusCode);
var putResponseContent = await putResponse.Content.ReadAsAsync <ResponseMsg>();
Assert.AreEqual($"Event #{invalidId} not found.", putResponseContent.Message);
}
public async Task Test_Events_CreateEvent_InvalidData()
{
// Arrange: create event binding model
// with invalid name: name == empty string
var invalidEventName = string.Empty;
var newEvent = new EventBindingModel()
{
Name = invalidEventName,
Place = "Beach",
Start = DateTime.Now.AddDays(1),
End = DateTime.Now.AddDays(2),
TotalTickets = 120,
PricePerTicket = 20
};
var eventsCountBefore = this.dbContext.Events.Count();
// Act
var postResponse = await this.httpClient.PostAsJsonAsync("/api/events/create", newEvent);
// Assert a "BadRequest" is returned
Assert.AreEqual(HttpStatusCode.BadRequest, postResponse.StatusCode);
var postResponseContent = await postResponse.Content.ReadAsStringAsync();
Assert.That(postResponseContent.Contains("The Name field is required."));
var eventsCountAfter = this.dbContext.Events.Count();
Assert.AreEqual(eventsCountBefore, eventsCountAfter);
}
public void Test_Edit_UnauthorizedUser()
{
// Arrange: get the "Open Fest" event with owner UserPeter
var openFestEvent = this.testDb.EventOpenFest;
// Create event binding model with changed event name
var changedName = "OpenFest 2021 (New Edition)";
var changedEvent = new EventBindingModel()
{
Name = changedName,
Place = openFestEvent.Place,
Start = openFestEvent.Start,
End = openFestEvent.End,
TotalTickets = openFestEvent.TotalTickets,
PricePerTicket = openFestEvent.PricePerTicket
};
// Act: invoke the controller method
var result = this.controller.Edit(openFestEvent.Id, changedEvent);
// Assert an "Unauthorized" result is returned
// because UserMaria is not the owner of the "Open Fest" event
var unauthorizedResult = result as UnauthorizedResult;
Assert.AreEqual((int)HttpStatusCode.Unauthorized, unauthorizedResult.StatusCode);
Assert.IsNotNull(unauthorizedResult);
// Assert the event's name is not edited
var editedEvent = this.dbContext.Events.Find(openFestEvent.Id);
Assert.IsNotNull(editedEvent);
Assert.AreEqual(openFestEvent.Name, editedEvent.Name);
}
public IActionResult PutEvent(int id, EventBindingModel eventModel)
{
var eventExists = this.dbContext.Events.Any(e => e.Id == id);
if (!eventExists)
{
return(NotFound(
new ResponseMsg {
Message = $"Event #{id} not found."
}));
}
var ev = this.dbContext.Events.Find(id);
if (GetCurrentUserId() != ev.OwnerId)
{
return(Unauthorized(
new ResponseMsg {
Message = "Cannot edit event, when not an owner."
}));
}
ev.Name = eventModel.Name;
ev.Place = eventModel.Place;
ev.Start = eventModel.Start.AddTicks(-(eventModel.Start.Ticks % TimeSpan.TicksPerSecond));
ev.End = eventModel.End.AddTicks(-(eventModel.End.Ticks % TimeSpan.TicksPerSecond));
ev.TotalTickets = eventModel.TotalTickets;
ev.PricePerTicket = eventModel.PricePerTicket;
this.dbContext.SaveChanges();
return(NoContent());
}
public async Task <IActionResult> GetAll([FromQuery] EventBindingModel collection)
{
if (string.IsNullOrWhiteSpace(collection?.Token))
{
return(BadRequest(GeneralMessage.TokenNotFound));
}
if (string.IsNullOrWhiteSpace(collection?.DeviceId))
{
return(BadRequest(GeneralMessage.DeviceIdNotFound));
}
try {
var model = _mapper.Map <EventGetPagingSchema>(collection);
var result = await _eventService.GetPagingAsync(model);
switch (model.StatusCode)
{
case 1:
return(Ok(data: _mapper.Map <IEnumerable <EventViewModel> >(result), totalPages: collection.TotalPages(model.RowsCount)));
case -1:
return(BadRequest(GeneralMessage.UserNotFound));
case -2:
return(BadRequest(GeneralMessage.UserIsNotActive));
case -3:
return(BadRequest(GeneralMessage.PhoneIsNotVerified));
}
}
catch (Exception ex) {
await _exceptionService.InsertAsync(ex, URL, IP);
}
return(InternalServerError());
}
public async Task <IActionResult> HomePageView(EventBindingModel model, IFormFile eventImage)
{
this.eventService.CreateEvent(eventMapper.NewEvent(model, eventImage, userManager.GetUserId(User)));
await base.UpdateEventsInCache();
return(ReturnMainView());
}
public ActionResult Add(int id)
{
var model = new EventBindingModel();
model.Id = id;
return(this.View(model));
}
public IActionResult HomePageView(EventBindingModel model, IFormFile eventImage)
{
this._eventService.CreateEvent(eventMapper.MapEventToDB(model, eventImage, _userManager.GetUserId(User)));
var task = new EventsTask(factory);
task.ProcessInScope(provider);
return(ReturnMainView());
}
public async Task <IActionResult> Edit(EventBindingModel model, IFormFile eventImage)
{
var viewModel = eventMapper.ModifiedEvent(model, eventImage, userManager.GetUserId(User));
this.eventService.EditEvent(viewModel);
await base.UpdateEventsInCache();
return(this.RedirectToAction("GetMyEvents"));
}
public void Test_Events_Create()
{
// Arrange: get the events count before the creation
int eventsCountBefore = this.dbContext.Events.Count();
// Set UserMaria as a currently logged in user
TestingUtils.AssignCurrentUserForController(
this.eventsController, this.testDb.UserMaria);
// Create a new event binding model
var newEventData = new EventBindingModel()
{
Name = "New Event " + DateTime.Now.Ticks,
Place = "Sofia",
Start = DateTime.Now.AddMonths(3),
End = DateTime.Now.AddMonths(3).AddDays(1),
TotalTickets = 500,
PricePerTicket = 20
};
// Act: invoke the controller method and cast the result
var result = this.eventsController.CreateEvent(newEventData)
as CreatedAtActionResult;
Assert.IsNotNull(result);
// Assert a "Created" result with the correct event data is returned
Assert.AreEqual((int)HttpStatusCode.Created, result.StatusCode);
var resultValue = result.Value as EventListingModel;
Assert.IsTrue(resultValue.Id > 0);
Assert.AreEqual(newEventData.Name, resultValue.Name);
Assert.AreEqual(newEventData.Place, resultValue.Place);
Assert.AreEqual(newEventData.Start.ToString("dd/MM/yyyy HH:mm"), resultValue.Start);
Assert.AreEqual(newEventData.End.ToString("dd/MM/yyyy HH:mm"), resultValue.End);
Assert.AreEqual(newEventData.PricePerTicket, resultValue.PricePerTicket);
Assert.AreEqual(newEventData.TotalTickets, resultValue.TotalTickets);
// Assert the new event is added to the db correctly
int eventsCountAfter = this.dbContext.Events.Count();
Assert.That(eventsCountAfter == eventsCountBefore + 1);
var newEventFromDb =
this.dbContext.Events.FirstOrDefault(e => e.Name == newEventData.Name);
Assert.IsTrue(newEventFromDb.Id > 0);
Assert.AreEqual(newEventData.Place, newEventFromDb.Place);
Assert.AreEqual(newEventData.Start, newEventFromDb.Start);
Assert.AreEqual(newEventData.End, newEventFromDb.End);
Assert.AreEqual(newEventData.PricePerTicket, newEventFromDb.PricePerTicket);
Assert.AreEqual(newEventData.TotalTickets, newEventFromDb.TotalTickets);
}
private static void AttachPositions(Event viewEvent, EventBindingModel model)
{
foreach (var position in viewEvent.Sport.Positions)
{
PositionModel newPosition = new PositionModel();
newPosition.EventId = viewEvent.Id;
newPosition.Id = position.Id;
newPosition.Name = position.Name;
newPosition.Team = position.Team;
model.Positions.Add(newPosition);
}
}
public IActionResult Edit(EventBindingModel model, IFormFile eventImage)
{
var viewModel = eventMapper.MapEditEventToDB(model, eventImage, _userManager.GetUserId(User));
this._eventService.EditEvent(viewModel);
var task = new EventsTask(factory);
task.ProcessInScope(provider);
return(this.RedirectToAction("GetMyEvents"));
}
public IHttpActionResult UpdateEvent([FromUri] int id, [FromBody] EventBindingModel model)
{
Exception ex = null;
try {
var e = model.GetEntity();
_dataProvider.SaveEntity <Event>(e);
} catch (Exception e) {
ex = e;
}
return(GetHttpActionResult(ex));
}
public ActionResult DeleteConfirmed(EventBindingModel bind)
{
var @event = db.Events.Find(bind.Id);
db.Events.Remove(@event);
var eventImages = @event.EventImages;
this.db.EventImages.RemoveRange(eventImages);
//var logo = @event.Logo;
//this.db.EventImages.RemoveRange(eventImages);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public Event NewEvent(EventBindingModel model, IFormFile eventImage, string adminId)
{
Event newEvent = new Event();
newEvent.Id = model.Id;
newEvent.Name = model.Title;
newEvent.Time = model.Time;
newEvent.SportId = model.SportId;
newEvent.Description = model.Description;
newEvent.Location = model.Location;
newEvent.Image = eventImage == null ? "defaultImage.jpg" : this.imageService.UploadImage(eventImage);
newEvent.AdminId = adminId;
return(newEvent);
}
public IActionResult Create()
{
var currentDate = DateTime.Now;
var startDate = new DateTime(currentDate.Year, currentDate.Month, currentDate.Day, currentDate.AddHours(1).Hour, currentDate.Minute, 0);
var endDate = new DateTime(currentDate.Year, currentDate.Month, currentDate.AddDays(1).Day, currentDate.AddHours(6).Hour, currentDate.Minute, 0);
EventBindingModel model = new EventBindingModel()
{
Name = "New Event",
Place = "Some Place",
Start = startDate,
End = endDate,
PricePerTicket = 10.00M,
TotalTickets = 100
};
return(View(model));
}
public void Test_Put_ValidId()
{
// Arrange: set UserMaria as a currently logged in user
TestingUtils.AssignCurrentUserForController(
this.eventsController, this.testDb.UserMaria);
// Create a new event in the database for editing
var newEvent = new Event()
{
Name = "Beach Party" + DateTime.Now.Ticks,
Place = "Ibiza",
Start = DateTime.Now.AddMonths(3),
End = DateTime.Now.AddMonths(3),
TotalTickets = 20,
PricePerTicket = 120.00m,
OwnerId = this.testDb.UserMaria.Id
};
this.dbContext.Add(newEvent);
this.dbContext.SaveChanges();
// Create an event binding model with changed event name
var changedEvent = new EventBindingModel()
{
Name = "House Party" + DateTime.Now.Ticks,
Place = newEvent.Place,
Start = newEvent.Start,
End = newEvent.End,
TotalTickets = newEvent.TotalTickets,
PricePerTicket = newEvent.PricePerTicket
};
// Act: invoke the controller method and cast the result
var result = this.eventsController.PutEvent(newEvent.Id, changedEvent)
as NoContentResult;
Assert.IsNotNull(result);
// Assert a "NoContent" result is returned
Assert.AreEqual((int)HttpStatusCode.NoContent, result.StatusCode);
// Assert the event in the database has a changed name
var newEventFromDb = this.dbContext.Events.Find(newEvent.Id);
Assert.AreEqual(newEventFromDb.Name, changedEvent.Name);
}
public ActionResult Create()
{
var countries = this.db.Countries;
var countryModels = Mapper.Map <IEnumerable <Country>, IEnumerable <CountryBindingModel> >(countries);
var cities = this.db.Cities.ToList();
var citiesModel =
Mapper.Map <IEnumerable <City>, IEnumerable <CityBindingModel> >(cities);
var venues = this.db.Venues;
var venuesModel = Mapper.Map <IEnumerable <Venue>, IEnumerable <VenueBindingModel> >(venues);
var bindingModel = new EventBindingModel
{
AvailableCountries = countryModels,
AvailableCities = citiesModel,
AvailableVenues = venuesModel
};
return(View(bindingModel));
}
public Event ModifiedEvent(EventBindingModel model, IFormFile eventImage, string adminId)
{
Event newEvent = new Event();
newEvent.Id = model.Id;
newEvent.Name = model.Title;
newEvent.Time = model.Time;
newEvent.SportId = model.SportId;
newEvent.Description = model.Description;
newEvent.Location = model.Location;
if (eventImage != null)
{
newEvent.Image = this.imageService.UploadImage(eventImage);
}
newEvent.AdminId = adminId;
return(newEvent);
}
