public async Task Map_Should_Not_Set_MeetupModel_Attendees_If_Meetup_Attendees_Is_Null_Or_Empty()
{
MeetupModelMapperMock mock = MeetupModelMapperMock.Create();
var meetup = new Meetup()
{
Id = 1,
Title = "Birinci",
Description = "Hede",
MeetupLink = "sample.com",
Date = DateTime.Now,
Attendees = null,
Photos = new[] { "" }
};
MeetupModel meetupModel = await mock.Map(meetup);
void AssertVerify()
{
mock.PersonService.Reset();
mock.PersonService.Verify(service => service.GetPeopleByNames(It.IsAny <IList <string> >()), Times.Never);
Assert.Null(meetupModel.Attendees);
}
AssertVerify();
meetup.Attendees = new string[0];
meetupModel = await mock.Map(meetup);
AssertVerify();
}
public async Task Map_Should_Not_Set_MeetupModel_Sponsors_If_Meetup_SponsorIds_Is_Null_Or_Empty()
{
MeetupModelMapperMock mock = MeetupModelMapperMock.Create();
var meetup = new Meetup()
{
Id = 1,
Title = "Birinci",
Description = "Hede",
MeetupLink = "sample.com",
Date = DateTime.Now,
SponsorIds = null
};
MeetupModel meetupModel = await mock.Map(meetup);
void AssertVerify()
{
mock.SponsorService.Reset();
mock.SponsorService.Verify(service => service.GetSponsorsByIds(It.IsAny <IList <int> >()), Times.Never);
Assert.Null(meetupModel.Sponsors);
}
AssertVerify();
meetup.SponsorIds = new int[0];
meetupModel = await mock.Map(meetup);
AssertVerify();
}
public static string GetMonthAndYear(this MeetupModel meetupModel)
{
if (!meetupModel.StartTime.HasValue)
{
return("TBA");
}
var start = meetupModel.StartTime.Value.ToEventTimeZone();
if (DateTime.Today.Year == start.Year)
{
if (DateTime.Today.DayOfYear == start.DayOfYear)
{
return(AppResources.Today);
}
if (DateTime.Today.DayOfYear + 1 == start.DayOfYear)
{
return(AppResources.Tomorrow);
}
}
var monthAndYear = start.ToString("MMMM yyyy", AppResources.Culture).ToTitleCase();
return($"{monthAndYear}");
}
public ActionResult Uninvite(int user, int theEvent, string returnTo)
{
//Check if user owns the event and remove the other user from it
MeetupModel model = new MeetupModel();
int? infoID = this.UserId();
if (infoID is null)
{
return(RedirectToAction("Index", "Home"));
}
Event uninviteToEvent = model.Events.SingleOrDefault(e => e.Id == theEvent && e.HostUserId == infoID);
Invite invite = model.Invites.SingleOrDefault(i => i.EventId == theEvent && i.UserId == user);
if (uninviteToEvent is null)
{
return(RedirectToAction("Index", "Home"));
}
//Remove invite
if (!(invite is null))
{
model.Invites.Remove(invite);
model.SaveChanges();
}
return(Redirect(returnTo));
}
public async Task Map_Should_Set_MeetupModel_Videos_If_Meetup_VideoIds_Is_Not_Null_Or_Empty()
{
MeetupModelMapperMock mock = MeetupModelMapperMock.Create();
var videoTitle = "Live Coding";
var meetup = new Meetup()
{
Id = 1,
Title = "Birinci",
Description = "Hede",
MeetupLink = "sample.com",
Date = DateTime.Now,
VideoIds = new[] { 1 }
};
mock.VideoService
.Setup(service => service.GetVideosByIds(It.Is <IList <int> >(list => list.Any(s => meetup.VideoIds.Contains(s)))))
.ReturnsAsync(() => new List <VideoModel> {
new VideoModel()
{
Id = 1, Title = videoTitle
}
});
MeetupModel meetupModel = await mock.Map(meetup);
mock.PersonService.Verify(service => service.GetPeopleByNames(It.IsAny <IList <string> >()), Times.Never);
mock.VideoService.Verify(service => service.GetVideosByIds(It.IsAny <IList <int> >()), Times.Once);
mock.SponsorService.Verify(service => service.GetSponsorsByIds(It.IsAny <IList <int> >()), Times.Never);
Assert.NotNull(meetupModel.Videos);
Assert.Equal(meetupModel.Videos.Length, meetup.VideoIds.Length);
Assert.Equal(videoTitle, meetupModel.Videos[0].Title);
}
/// <summary>
/// An action returning a page where a user can (un)invite another user to an event
/// </summary>
/// <param name="id">The id of the user to (un)invite</param>
/// <returns>if user exists: the (un)invite page</returns>
public ActionResult Invite(int id)
{
int?infoID = this.UserId();
if (infoID is null)
{
return(RedirectToAction("Index", "Home"));
}
//Finds the user and the events the user is in and isnt in
MeetupModel model = new MeetupModel();
InviteToEventModel viewModel = new InviteToEventModel();
viewModel.IsInvitedTo = model.Events.Where(e => e.HostUserId == infoID && e.Invites.Any(u => u.UserId == id)).ToList();
viewModel.CanInviteTo = model.Events.Where(e => e.HostUserId == infoID && !e.Invites.Any(u => u.UserId == id)).ToList();
viewModel.Inviting = model.Users.SingleOrDefault(u => u.Id == id);
if (viewModel.Inviting is null)
{
return(RedirectToAction("List", "User"));
}
viewModel.CameFrom = Request.UrlReferrer.ToString();
return(View(viewModel));
}
/// <summary>
/// An action returning a page used to create a meeting list
/// </summary>
/// <param name="id">The event to create the list for</param>
/// <returns>if the user owns the event: Returns a page where the user can create a meeting list</returns>
public ActionResult CreateList(int id)
{
MeetupModel model = new MeetupModel();
//Checks if the user owns the event or not
int? infoID = this.UserId();
Event theEvent = model.Events.SingleOrDefault(e => e.Id == id && e.HostUserId == infoID);
if (theEvent is null)
{
return(RedirectToAction("Index", "Home"));
}
EventListCreationModel viewModel = new EventListCreationModel();
viewModel.EventInformation = theEvent;
viewModel.EventId = theEvent.Id;
if (viewModel.EventInformation.Invites.Count < 2)
{
return(View("NotEnoughPeople", viewModel));
}
return(View(viewModel));
}
/// <summary>
/// An action returning a page showing all users
/// </summary>
/// <param name="viewModel">The view model containing search information</param>
/// <returns>Returns a page with a list of all users (only returns users searched for if searched)</returns>
public ActionResult Index(UserListModel viewModel)
{
MeetupModel model = new MeetupModel();
if (viewModel is null)
{
viewModel = new UserListModel();
}
viewModel.Users = model.Users.ToList();
//Get users
if (viewModel.PageNumber <= 0)
{
viewModel.PageNumber = 1;
}
IEnumerable <User> users = viewModel.Users;
if (!string.IsNullOrWhiteSpace(viewModel.SearchString))
{
//Search for a user's name
users = users.Where(u => u.FullName.ToLower().Contains(viewModel.SearchString.ToLower())).ToList();
}
viewModel.Users = users.Skip((viewModel.PageNumber - 1) * usersPerPage).Take(usersPerPage).ToList();
//Calculate page numbers
viewModel.MaxPages = (int)Math.Ceiling(users.Count() / (double)usersPerPage);
viewModel.FirstShownPage = Math.Max(1, viewModel.PageNumber - pagesToShow);
viewModel.LastShownPage = Math.Min(viewModel.MaxPages, viewModel.PageNumber + pagesToShow) + 1;
return(View(viewModel));
}
public async Task Map_Should_Set_MeetupModel_Attendees_If_Meetup_Attendees_Is_Not_Null_Or_Empty()
{
MeetupModelMapperMock mock = MeetupModelMapperMock.Create();
var attendeeName = "Deniz İrgin";
var meetup = new Meetup()
{
Id = 1,
Title = "Birinci",
Description = "Hede",
MeetupLink = "sample.com",
Date = DateTime.Now,
Attendees = new[] { attendeeName }
};
mock.PersonService
.Setup(service => service.GetPeopleByNames(It.Is <IList <string> >(list => list.Any(s => meetup.Attendees.Contains(s)))))
.ReturnsAsync(() => new List <Person> {
new Person()
{
Id = 1, Name = attendeeName
}
});
MeetupModel meetupModel = await mock.Map(meetup);
mock.PersonService.Verify(service => service.GetPeopleByNames(It.IsAny <IList <string> >()), Times.Once);
mock.VideoService.Verify(service => service.GetVideosByIds(It.IsAny <IList <int> >()), Times.Never);
mock.SponsorService.Verify(service => service.GetSponsorsByIds(It.IsAny <IList <int> >()), Times.Never);
Assert.NotNull(meetupModel.Attendees);
Assert.Equal(meetupModel.Attendees.Length, meetup.Attendees.Length);
Assert.Equal(attendeeName, meetupModel.Attendees[0].Name);
}
public async Task GetMeetup_By_Id_Should_Return_Call_IMeetupModelMapper_Map()
{
MeetupServiceMock mock = MeetupServiceMock.Create();
var id = 1;
var meetup = new Meetup()
{
Id = id, Title = "Dotnet Core"
};
mock.MeetupRepository
.Setup(repository => repository.GetMeetupById(It.Is <int>(i => i == id)))
.ReturnsAsync(() => new Meetup()
{
Id = id, Title = "Dotnet Core"
});
mock.MeetupModelMapper
.Setup(mapper => mapper.Map(It.Is <Meetup>(m => m.Id == meetup.Id && m.Title == meetup.Title)))
.ReturnsAsync(() => new MeetupModel());
MeetupModel meetupModel = await mock.GetMeetupById(id);
mock.MeetupModelMapper.Verify(mapper => mapper.Map(It.IsAny <Meetup>()), Times.Once);
Assert.NotNull(meetupModel);
}
public async Task <MeetupModel> GetMeetupById(int id)
{
Meetup meetup = await _meetupRepository.GetMeetupById(id);
MeetupModel meetupModel = await _meetupModelMapper.Map(meetup);
return(meetupModel);
}
public MeetupDetailsPage(MeetupModel meetup)
{
this.InitializeComponent();
this.BindingContext = new MeetupDetailsViewModel(this.Navigation, meetup);
this.ItemId = meetup.Id;
}
public static string GetDisplayDate(this MeetupModel meetupModel)
{
if (!meetupModel.StartTime.HasValue || !meetupModel.EndTime.HasValue || meetupModel.StartTime.Value.IsTba())
{
return(AppResources.ToBeAnnounced);
}
return(meetupModel.StartTime.Value.ToString("d"));
}
public async Task <ActionResult> DeleteConfirmed(int id)
{
MeetupModel meetupModel = await db.Meetup.FindAsync(id);
db.Meetup.Remove(meetupModel);
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
public async Task Map_Should_Return_Null_If_Meetup_Is_Null()
{
MeetupModelMapperMock mock = MeetupModelMapperMock.Create();
Meetup meetup = null;
MeetupModel meetupModel = await mock.Map(meetup);
Assert.Null(meetupModel);
}
public async Task <ActionResult> Edit([Bind(Include = "id")] MeetupModel meetupModel)
{
if (ModelState.IsValid)
{
db.Entry(meetupModel).State = EntityState.Modified;
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
return(View(meetupModel));
}
public MeetupViewModel(INavigation navigation, MeetupModel meetupModel = null)
: base(navigation)
{
this.MeetupModel = meetupModel;
MessagingCenter.Subscribe <LocalizedResources>(
this,
MessageKeys.LanguageChanged,
sender => this.OnPropertyChanged(nameof(this.MeetupDate)));
this.TapVenueCommand = new Command(this.OnVenueTapped);
}
public async Task <ActionResult> Create([Bind(Include = "id")] MeetupModel meetupModel)
{
if (ModelState.IsValid)
{
db.Meetup.Add(meetupModel);
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
return(View(meetupModel));
}
/// <summary>
/// An action returning a page to a user can edit their profile
/// </summary>
/// <returns>If logged in: Returns a page where a user can edit their profile</returns>
public ActionResult Edit()
{
MeetupModel model = new MeetupModel();
List <User> users = model.Users.ToList();
int?infoID = this.UserId();
if (infoID is null)
{
return(RedirectToAction("Index", "Home"));
}
User editUser = users.SingleOrDefault(userInfo => userInfo.Id == infoID);
UserEditorModel editModel = new UserEditorModel();
//Get business list
List <Business> selectedBusinesses = editUser.GetBusinesses().ToList();
List <Business> unselectedBusinesses = model.Businesses.ToList().Except(selectedBusinesses).ToList();
//Get interest list
List <Interest> selectedInterests = editUser.GetInterests().ToList();
List <Interest> unselectedInterests = model.Interests.ToList().Except(selectedInterests).ToList();
editModel.UnselectedBusinesses = unselectedBusinesses;
editModel.SelectedBusinesses = selectedBusinesses;
editModel.UnselectedInterests = unselectedInterests;
editModel.SelectedInterests = selectedInterests;
editModel.Description = editUser.Description;
editModel.FirstName = editUser.FirstName;
editModel.LastName = editUser.LastName;
editModel.Address = new AddressModel();
editModel.Address.City = editUser.Address.CityName;
editModel.Address.Country = editUser.Address.Country;
editModel.Address.CityZipCode = editUser.Address.ZipCode.ToString();
editModel.Address.StreetName = editUser.Address.StreetName;
editModel.Address.StreetNumber = editUser.Address.StreetNumber;
editModel.Organizations = new List <OrganizationModel>();
foreach (UsersOrganizations organization in editUser.UsersOrganizations)
{
editModel.Organizations.Add(new OrganizationModel()
{
Id = organization.Id,
Name = organization.Organization.Name,
EndDate = organization.EndDate,
StartDate = organization.StartDate,
State = "old"
});
}
return(View(editModel));
}
// GET: MeetupModels/Delete/5
public async Task <ActionResult> Delete(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
MeetupModel meetupModel = await db.Meetup.FindAsync(id);
if (meetupModel == null)
{
return(HttpNotFound());
}
return(View(meetupModel));
}
public async Task <IActionResult> MeetupById(int id)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
MeetupModel meetupModel = await _meetupService.GetMeetupById(id);
if (meetupModel == null)
{
return(NotFound());
}
return(Ok(meetupModel));
}
/// <summary>
/// An action returning a page with a list of all seances in an event
/// </summary>
/// <param name="id">The id of the event to show seances for</param>
/// <returns>If user is in the event: Returns a page to view seances for the event</returns>
public ActionResult Seances(int id)
{
//Get event and make sure user is in it
MeetupModel model = new MeetupModel();
int? infoId = this.UserId();
if (infoId is null)
{
return(RedirectToAction("Index", "Home"));
}
SeanceViewModel viewModel = new SeanceViewModel();
viewModel.Event = model.Events.SingleOrDefault(e => e.Id == id && (e.HostUserId == infoId || e.Invites.Any(u => u.UserId == infoId)));
if (viewModel.Event is null)
{
return(RedirectToAction("Index", "Home"));
}
//sort seance list
List <Seance> seances = viewModel.Event.Seances.ToList();
List <Seance> sortedMeetings = new List <Seance>();
foreach (Seance meeting in seances)
{
bool sorted = false;
for (int i = 0; i < sortedMeetings.Count; i++)
{
if (meeting.MeetingNumber < sortedMeetings[i].MeetingNumber)
{
sortedMeetings.Insert(i, meeting);
sorted = true;
break;
}
}
if (!sorted)
{
sortedMeetings.Add(meeting);
}
}
viewModel.Seances = viewModel.Event.Seances.ToList();
viewModel.UserId = infoId.Value;
return(View(viewModel));
}
/// <summary>
/// An action returning a page showing an event
/// </summary>
/// <param name="id">The id of the event to show</param>
/// <returns>If user is in the event: Returns a page containing information about the event</returns>
public ActionResult Page(int id)
{
//Find the event and makes sure you are in it (dont show if the user isnt invited/owns the event)
int? infoID = this.UserId();
MeetupModel model = new MeetupModel();
EventPageModel viewModel = new EventPageModel();
viewModel.Event = model.Events.SingleOrDefault(e => e.Id == id && (e.Invites.Any(i => i.UserId == infoID) || e.HostUserId == infoID));
if (viewModel.Event is null)
{
return(RedirectToAction("Index", "Home"));
}
//Check if the user owns the event
viewModel.UserID = infoID.Value;
if (viewModel.Event.HostUserId == infoID)
{
viewModel.EventOwner = true;
}
//Creates the list of all users invited to the event
viewModel.Invited = viewModel.Event.Invites.Any(i => i.UserId == infoID);
viewModel.InvitedUsers = viewModel.Event.GetUsers().ToList();
//Creates the list of all seances/meetings with this user
List <Seance> seances = viewModel.Event.Seances.ToList();
viewModel.Meetings = new List <Meeting>();
foreach (Seance seance in seances)
{
Meeting meeting = seance.Meetings.SingleOrDefault(m => m.MeetingContainsUser(infoID.Value));
if (!(meeting is null))
{
viewModel.Meetings.Add(meeting);
}
}
//Gets a list of the user's wishes for the event
viewModel.UserWishes = new List <Wish>();
User user = model.Users.SingleOrDefault(u => u.Id == viewModel.UserID);
viewModel.UserWishes = user.Wishes.Where(w => w.EventId == viewModel.Event.Id).ToList();
return(View(viewModel));
}
public async Task <ActionResult> Register(RegisterViewModel model)
{
if (ModelState.IsValid)
{
//find user id
MeetupModel meetupModel = new MeetupModel();
List <User> users = meetupModel.Users.ToList();
Random random = new Random();
int randomID;
do
{
randomID = random.Next(0, int.MaxValue);
}while(users.Any(userInfo => userInfo.Id == randomID));
//Check picture
if (!model.Picture.ContentType.Contains("image"))
{
ModelState.AddModelError("Picture", "Feltet \"Profil billed\" accepterer kun billeder.");
return(View(model));
}
string pictureDataString = model.Picture.PictureFileToString();
//add user
ApplicationUser user = new ApplicationUser {
UserName = model.Email, Email = model.Email, InfoId = randomID
};
IdentityResult result = await UserManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
await SignInManager.SignInAsync(user, isPersistent : false, rememberBrowser : false);
Address usersAddress = new Address(model.Address.Country, model.Address.City, Convert.ToInt32(model.Address.CityZipCode), model.Address.StreetName, model.Address.StreetNumber);
User newUser = new User(model.FirstName, model.LastName, model.Description, "data:image/png;base64," + pictureDataString, model.Email, usersAddress, randomID);
meetupModel.Users.Add(newUser);
meetupModel.SaveChanges();
return(RedirectToAction("Profile", "Users", new { Id = randomID }));
}
AddErrors(result);
}
// If we got this far, something failed, redisplay form
return(View(model));
}
/// <summary>
/// An action returning the home page
/// </summary>
/// <returns>Returns the home page</returns>
public ActionResult Index()
{
//If user ins't logged in return normal home page
int?infoID = this.UserId();
if (infoID is null)
{
return(View());
}
//If user is logged in return information page
MeetupModel model = new MeetupModel();
UserIndexModel viewModel = new UserIndexModel();
User user = model.Users.SingleOrDefault(u => u.Id == infoID);
//Create list of upcoming events
viewModel.NextEvents = new List <Event>();
List <Invite> invites = user.Invites.ToList();
foreach (Invite invite in invites)
{
if (invite.Event.BeginningTime >= DateTime.Now)
{
viewModel.NextEvents.Add(invite.Event);
}
}
viewModel.NextEvents.Sort(Event.Sort);
viewModel.NextEvents = viewModel.NextEvents.Take(5).ToList();
//Get wish count for the events
viewModel.WishesPerEvent = new List <int>();
for (int i = 0; i < viewModel.NextEvents.Count; i++)
{
viewModel.WishesPerEvent.Add(user.Wishes.Count(w => w.EventId == viewModel.NextEvents[i].Id));
}
//Create list of newly invited to events
viewModel.NewEvents = new List <Event>();
invites.Sort(Invite.Sort);
invites = invites.Take(5).ToList();
foreach (Invite invite in invites)
{
viewModel.NewEvents.Add(invite.Event);
}
return(View("UserIndex", viewModel));
}
public async Task <IEnumerable <MeetupModel> > Map(IEnumerable <Meetup> meetups)
{
if (meetups == null)
{
return(null);
}
IList <MeetupModel> meetupModels = new List <MeetupModel>();
foreach (Meetup meetup in meetups)
{
MeetupModel meetupModel = await Map(meetup);
meetupModels.Add(meetupModel);
}
return(meetupModels);
}
public MeetupDetailsViewModel(INavigation navigation, MeetupModel meetupModel = null)
: base(navigation)
{
MeetupModel = meetupModel;
MessagingCenter.Subscribe <LocalizedResources>(
this,
MessageKeys.LanguageChanged,
sender =>
{
MeetupDetailsPageItems.ReplaceRange(GetMeetupDetailsPageItems());
}
);
UpdateRemainderStatusCommand.Execute(parameter: null);
MeetupDetailsPageItems.ReplaceRange(GetMeetupDetailsPageItems());
}
/// <summary>
/// An action returning a page showing all the user's events
/// </summary>
/// <returns>If user is logged in: Returns a page showing events</returns>
public ActionResult Index()
{
MeetupModel model = new MeetupModel();
int? infoID = this.UserId();
if (infoID is null)
{
return(RedirectToAction("Index", "Home"));
}
ViewEventsModel viewModel = new ViewEventsModel();
User thisUser = model.Users.SingleOrDefault(userInfo => userInfo.Id == infoID);
viewModel.OwnedEvents = model.Events.Where(e => e.HostUserId == thisUser.Id).ToList();
viewModel.InvitedToEvents = thisUser.Invites.ToList();
return(View(viewModel));
}
/// <summary>
/// An action returning a page where the user can edit a wish
/// </summary>
/// <param name="id">The wish to edit</param>
/// <returns>if wish exists and is owned by the user: The edit page for the wish</returns>
public ActionResult Edit(int id)
{
//Checks if user is logged in, is in the event and owns the wish
int?infoID = this.UserId();
if (infoID is null)
{
return(RedirectToAction("Index", "Home"));
}
MeetupModel model = new MeetupModel();
Wish editingWish = model.Wishes.SingleOrDefault(w => w.UserId == infoID && w.Id == id);
if (editingWish is null || !editingWish.Event.Invites.Any(u => u.UserId == infoID))
{
return(RedirectToAction("Index", "Home"));
}
WishEditCreateModel viewModel = GetFilledWishCreateEditModel(editingWish.Event, infoID.Value);
viewModel.WishInformation = editingWish;
viewModel.WishId = editingWish.Id;
//Creates list of chosen and unchosen interests
viewModel.ChosenInterestsList = viewModel.WishInformation.GetInterests().ToList();
viewModel.UnchosenInterests = viewModel.UnchosenInterests.Except(viewModel.ChosenInterestsList).ToList();
//Creates list of chosen and unchosen businesses
viewModel.ChosenBusinessesList = viewModel.WishInformation.GetBusinesses().ToList();
viewModel.UnchosenBusinesses = viewModel.UnchosenBusinesses.Except(viewModel.ChosenBusinessesList).ToList();
//Checks if the wish was for another user
if (!(viewModel.WishInformation.WishUser is null))
{
viewModel.ChosenName = viewModel.WishInformation.WishUser.FullName;
}
//Finds the organization the wish was wishing for
if (!(viewModel.WishInformation.WishOrganizationId is null))
{
viewModel.SelectedOrganizationIndex = viewModel.Organizations.IndexOf(viewModel.Organizations.SingleOrDefault(o => o.Id == viewModel.WishInformation.WishOrganizationId));
}
public static string GetDisplayTime(this MeetupModel e)
{
if (!e.StartTime.HasValue || !e.EndTime.HasValue || e.StartTime.Value.IsTba())
{
return(AppResources.ToBeAnnounced);
}
var start = e.StartTime.Value.ToEventTimeZone();
if (e.IsAllDay)
{
return(AppResources.AllDay);
}
var startString = start.ToString("t", AppResources.Culture);
var end = e.EndTime.Value.ToEventTimeZone();
var endString = end.ToString("t", AppResources.Culture);
return($"{startString}–{endString}");
}
