public void ProfileApprovedEventUserPreferenceTest()
{
const string category = "test";
var events = new[]
{
new Event
{
Category = category,
IsApproved = true
}
};
var mockRepository = new Mock <IRepository <Event> >();
mockRepository.Setup(r => r.GetAll())
.Returns(events.AsQueryable());
var user = new DB.Models.User
{
Id = this.username,
Preferences = new List <Preference>
{
new Preference
{
Category = category
}
}
};
var userManager = new Mock <AppUserManager>(
new UserStore <DB.Models.User>());
userManager.Setup(m => m.FindByIdAsync(It.IsAny <string>()))
.Returns(Task.FromResult(user));
var controllerContext = new Mock <ControllerContext>();
controllerContext.SetupGet(x => x.HttpContext.User)
.Returns(this.mockPrincipal.Object);
var controller =
new UserController(null, mockRepository.Object, null)
{
ControllerContext = controllerContext.Object,
UserManager = userManager.Object
};
var viewResult = controller.Profile();
Assert.IsNotNull(controller.ViewBag.ReturnURL);
var modelResult = (ProfileViewModel)viewResult.Model;
Assert.AreEqual(user, modelResult.User);
Assert.AreEqual(0, modelResult.Categories.Count());
Assert.AreEqual(null, modelResult.SelectedCategory);
mockRepository.Verify(r => r.GetAll(), Times.Once);
}
public ActionResult OnPostAdoptDog()
{
DB.Models.User owner = GetCurrentUser(HttpContext);
Dog dog = dogController.GetDog(owner, AdoptionDogID);
dogController.ConfirmAdoption(owner, dog, AdoptionConfirmed);
return(new RedirectToPageResult("/User/Home"));
}
public void AddExistentBookmarkTest()
{
const int eventId = 1;
var eventToAdd = new Event
{
Id = eventId,
BookmarkedBy = new List <DB.Models.User>()
};
DB.Models.User user = new DB.Models.User
{
Id = this.username,
BookmarkedEvents = new List <Event> {
eventToAdd
}
};
eventToAdd.BookmarkedBy.Add(user);
var events = new[] { eventToAdd };
var mockRepository = new Mock <IRepository <Event> >();
mockRepository.Setup(r => r.GetById(It.IsAny <int>()))
.Returns(events[0]);
mockRepository.Setup(r => r.Save()).Returns(0);
var userManager = new Mock <AppUserManager>(
new UserStore <DB.Models.User>());
userManager.Setup(m => m.FindByIdAsync(It.IsAny <string>()))
.Returns(Task.FromResult(user));
var controllerContext = new Mock <ControllerContext>();
controllerContext.SetupGet(x => x.HttpContext.User)
.Returns(this.mockPrincipal.Object);
var controller =
new UserController(null, mockRepository.Object, null)
{
ControllerContext = controllerContext.Object,
UserManager = userManager.Object
};
Assert.IsTrue(events[0].BookmarkedBy.Contains(user));
Assert.IsTrue(user.BookmarkedEvents.Contains(events[0]));
controller.AddBookmark(eventId);
Assert.IsTrue(events[0].BookmarkedBy.Contains(user));
Assert.IsTrue(user.BookmarkedEvents.Contains(events[0]));
Assert.IsNull(controller.TempData["message"]);
Assert.IsNotNull(controller.TempData["error"]);
mockRepository.Verify(r => r.GetById(It.IsAny <int>()), Times.Once);
mockRepository.Verify(r => r.Save(), Times.Once);
}
API.Resource.User IUserRepository.getUserByID(int ID)
{
DB.Models.User gotUser = context.User.Where(user => user.ID == ID).SingleOrDefault();
API.Resource.User tobeReturned = null;
if (gotUser != null)
{
tobeReturned = mapper.Map <API.Resource.User>(gotUser);
}
return(tobeReturned);
}
public void ViewEventsBookmarkedEventTest()
{
var user = new DB.Models.User
{
Id = this.username
};
Event bookmarkedEvent = new Event()
{
IsApproved = true,
BookmarkedBy = new List <DB.Models.User> {
user
},
Category = "test"
};
user.BookmarkedEvents = new List <Event> {
bookmarkedEvent
};
var events = new[] { bookmarkedEvent };
var mockRepository = new Mock <IRepository <Event> >();
mockRepository.Setup(r => r.GetAll()).Returns(events.AsQueryable);
var userManager = new Mock <AppUserManager>(
new UserStore <DB.Models.User>());
userManager.Setup(m => m.FindByIdAsync(It.IsAny <string>()))
.Returns(Task.FromResult(user));
var controllerContext = new Mock <ControllerContext>();
controllerContext.SetupGet(x => x.HttpContext.User)
.Returns(this.mockPrincipal.Object);
var controller =
new UserController(null, mockRepository.Object, null)
{
ControllerContext = controllerContext.Object,
UserManager = userManager.Object
};
var viewResult = controller.ViewEvents();
Assert.AreEqual(
1, ((ViewEventsUserModel)viewResult.Model).Events.Count);
Assert.IsTrue(((ViewEventsUserModel)viewResult.Model)
.Events.ToArray()[0].Value);
mockRepository.Verify(r => r.GetAll(), Times.Exactly(2));
}
public async Task <IJResponse> Login(
[FromServices] OpenRCT2org.IUserApi userApi,
[FromServices] IUserSessionRepository userSessionRepository,
[FromServices] DB.Abstractions.IUserRepository userRepository,
[FromBody] JLoginRequest body)
{
try
{
Guard.ArgumentNotNull(body);
Guard.ArgumentNotNull(body.user);
Guard.ArgumentNotNull(body.password);
}
catch
{
return(JResponse.Error(JErrorMessages.InvalidRequest));
}
_logger.LogInformation("User login: {0}", body.user);
OpenRCT2org.JUser orgUser;
try
{
orgUser = await userApi.AuthenticateUser(body.user, body.password);
}
catch (OpenRCT2org.OpenRCT2orgException)
{
return(JResponse.Error(ErrorAuthenticationFailed));
}
var ourUser = await userRepository.GetUserFromOpenRCT2orgIdAsync(orgUser.userId);
if (ourUser == null)
{
ourUser = new DB.Models.User()
{
OpenRCT2orgId = orgUser.userId,
UserName = orgUser.name
};
await userRepository.InsertUserAsync(ourUser);
}
string token = await userSessionRepository.CreateToken(orgUser.userId);
return(new JLoginResponse()
{
status = JStatus.OK,
user = orgUser.name,
token = token
});
}
public override async Task Invoke(object message, TelegramBotClient bot)
{
Message msg = message as Message;
DB.Models.User newUser = new DB.Models.User(msg.From.Id, msg.From.Username, (int)Utils.Enums.States.Default);
if (DB.Controllers.MainController.Users.GetFirstUser(newUser.Id) != null)
{
await Utils.Markup.SendMsg(msg, $"User {newUser.Username} already authorized.", bot);
}
else if (DB.Controllers.MainController.Users.AddUser(newUser).Result)
{
await Utils.Markup.SendMsg(msg, $"Welcome {newUser.Username}!\nYou are authorized.", bot);
}
await Task.CompletedTask;
}
public void RemoveBookmarkNotNullOrIsEmptyReturnURLTest()
{
const int eventId = 1;
var eventToRemove = new Event
{
Id = eventId,
BookmarkedBy = new List <DB.Models.User>()
};
var user = new DB.Models.User
{
Id = this.username,
BookmarkedEvents = new List <Event>()
};
var mockRepository = new Mock <IRepository <Event> >();
mockRepository.Setup(r => r.GetById(It.IsAny <int>()))
.Returns(eventToRemove);
mockRepository.Setup(r => r.Save()).Returns(0);
var userManager = new Mock <AppUserManager>(
new UserStore <DB.Models.User>());
userManager.Setup(m => m.FindByIdAsync(It.IsAny <string>()))
.Returns(Task.FromResult(user));
var controllerContext = new Mock <ControllerContext>();
controllerContext.SetupGet(x => x.HttpContext.User)
.Returns(this.mockPrincipal.Object);
var controller =
new UserController(null, mockRepository.Object, null)
{
ControllerContext = controllerContext.Object,
UserManager = userManager.Object
};
string url = "someURL";
var res = (RedirectResult)controller.RemoveBookmark(eventId, url);
Assert.AreEqual(url, res.Url);
mockRepository.Verify(r => r.GetById(It.IsAny <int>()), Times.Once);
mockRepository.Verify(r => r.Save(), Times.Once);
}
public async Task <ActionResult> OnPostEditDogAsync()
{
DB.Models.User owner = GetCurrentUser(HttpContext);
Dog dog = await dogController.EditDog(
owner,
PopupDogName,
PopupDogRace,
PopupDogBirthDate,
PopupDogSex,
PopupDogUpForAdoption,
PopupDogAdopter,
PopupDogImage,
PopupDogID,
PopupDogPrevImageName);
return(new RedirectToPageResult("/User/Home"));
}
private void FillDogList()
{
List <Dog> regDogs = new List <DB.Models.Dog>();
DB.Models.User owner = GetCurrentUser(HttpContext);
regDogs = dogController.GetDogs(owner);
UserController userController = new UserController(db);
Dogs = new List <ViewModels.DogViewModel>();
foreach (Dog dog in regDogs)
{
DogViewModel viewDog = new DogViewModel(dog);
if (!string.IsNullOrEmpty(dog.AdopterName))
{
UserResult uResult = userController.GetUser(dog.AdopterName);
if (uResult.GetStatus() == UserResult.UserResultStatus.FOUND)
{
viewDog.AdopterEmail = uResult.GetUser().Email;
}
}
Dogs.Add(viewDog);
}
/*DB.Models.Dog apa = new DB.Models.Dog();
* apa.Name = "Apa";
* apa.Image = "apa.jpg";
* apa.Sex = "Female";
* apa.Race = "Mešanac";
* apa.BirthDate = DateTime.Parse("12.6.2020");
* DB.Models.Dog pega = new DB.Models.Dog();
* pega.Name = "Pega";
* pega.Image = "pega.jpg";
* pega.Sex = "Male";
* pega.Race = "Mešanac";
* pega.BirthDate = DateTime.Parse("12.6.2020");
*
* Dogs.Add(apa);
* Dogs.Add(pega);*/
}
public void ViewEventsNoApprovedEventsTest()
{
var events = new Event[] { };
var user = new DB.Models.User()
{
Id = this.username
};
var mockRepository = new Mock <IRepository <Event> >();
mockRepository.Setup(r => r.GetAll()).Returns(events.AsQueryable);
var userManager = new Mock <AppUserManager>(
new UserStore <DB.Models.User>());
userManager.Setup(m => m.FindByIdAsync(It.IsAny <string>()))
.Returns(Task.FromResult(user));
var controllerContext = new Mock <ControllerContext>();
controllerContext.SetupGet(x => x.HttpContext.User)
.Returns(this.mockPrincipal.Object);
var controller =
new UserController(null, mockRepository.Object, null)
{
ControllerContext = controllerContext.Object,
UserManager = userManager.Object
};
var viewResult = controller.ViewEvents();
Assert.AreEqual(
0, ((ViewEventsUserModel)viewResult.Model).Events.Count);
mockRepository.Verify(r => r.GetAll(), Times.Exactly(2));
}
public void ViewEventsTest()
{
var events = new List <Event>
{
new Event
{
Id = 1,
Name = "Test 1",
Address = "Test 1",
DateTime = DateTime.Now,
Duration = TimeSpan.FromHours(2),
Url = "https://www.event1.test.com",
Description = "A test event",
Category = "Test",
IsApproved = true
},
new Event
{
Id = 2,
Name = "Test 2",
Address = "Test 2",
DateTime = DateTime.Now,
Duration = TimeSpan.FromHours(2),
Url = "https://www.event2.test.com",
Description = "A test event",
Category = "Test",
IsApproved = true
}
};
var user = new DB.Models.User
{
Id = userId,
BookmarkedEvents = new List <Event> {
events[0]
}
};
var mockEvents = new Mock <IRepository <Event> >();
mockEvents.Setup(repo => repo.GetAll())
.Returns(events.AsQueryable());
var mockManager = new Mock <AppUserManager>(
new UserStore <DB.Models.User>());
mockManager.Setup(m => m.FindByIdAsync(userId))
.Returns(Task.FromResult(user));
var mockContext = new Mock <ControllerContext>();
mockContext.SetupGet(x => x.HttpContext.User)
.Returns(this.mockPrincipal.Object);
var controller = new EditorController(mockEvents.Object, null)
{
ControllerContext = mockContext.Object,
UserManager = mockManager.Object
};
var result = controller.ViewEvents().Result;
var model = result.Model as ViewEventsUserModel;
Assert.IsNotNull(model);
Assert.AreEqual(events.Count, model.Events.Count);
Assert.AreEqual(true, model.Events[events[0]]);
Assert.AreEqual(false, model.Events[events[1]]);
}
public void OnGetAsync()
{
this.user = GetCurrentUser(HttpContext);
this.Username = user.Username;
FillDogList();
}
void IUserRepository.createUser(API.Resource.User user)
{
DB.Models.User toBeAdded = mapper.Map <DB.Models.User>(user);
context.User.Add(toBeAdded);
}
void IUserRepository.updateUser(API.Resource.User user)
{
DB.Models.User update = mapper.Map <DB.Models.User>(user);
context.User.Update(update);
}
API.Resource.User IUserRepository.getUserByName(string name)
{
DB.Models.User byName = context.User.Where(user => user.Username.Equals(name)).Single();
return(mapper.Map <API.Resource.User>(byName));
}
public ActionResult OnPostAdoptDog()
{
DB.Models.User newOwner = GetCurrentUser(HttpContext);
dogController.WantToAdopt(newOwner, AdoptDogID);
return(new RedirectToPageResult("/User/Home"));
}
public void OnGet()
{
DB.Models.User owner = GetCurrentUser(HttpContext);
Dogs = dogController.GetOtherPeoplesDogs(owner, GetFilter());
}
