public void GivenValidConnectionDetails_WhenDeleteConnectionCalled_ReturnCorrectCombinedProfileViewModel()
{
// Arrange
Connection coonection = new Connection();
coonection.UserId = 5;
coonection.OtherUserId = 10;
CombinedUserProfilesViewModel combinedDetails = new CombinedUserProfilesViewModel();
combinedDetails.Connection = coonection;
using (var scope = Container.BeginLifetimeScope())
{
_profilesController = scope.Resolve <ProfilesController>();
_profilesController.CreateConnectionBetweenUsers(combinedDetails);
// Act
var result = _profilesController.DeleteConnectionBetweenUsers(combinedDetails) as RedirectToRouteResult;
// Assert
Assert.IsNotNull(result);
var values = result.RouteValues.Values;
var userDetails = values.First();
Assert.AreSame(userDetails, combinedDetails.MyUserDetails);
Assert.IsTrue(values.Contains(CombinedUserProfilesViewModel.Success));
Assert.IsTrue(values.Contains(controllerName));
Assert.IsTrue(values.Contains(actionCalledOtherUsersProfile));
}
}
public async Task GetReturnsResultsWithExpectedSortOrderTest()
{
var source = Model.Create <List <ProfileResult> >();
var expected = (from x in source
orderby x.Status descending, x.YearStartedInTech ?? 0 descending, x.BirthYear ??
DateTimeOffset.UtcNow.Year
select x).ToList();
var filters = new List <ProfileFilter>();
var manager = Substitute.For <IProfileSearchQuery>();
var sut = new ProfilesController(manager);
using (var tokenSource = new CancellationTokenSource())
{
manager.GetProfileResults(filters, tokenSource.Token).Returns(source);
var actual = await sut.Get(filters, tokenSource.Token).ConfigureAwait(false);
actual.Should().BeOfType <OkObjectResult>();
var result = actual.As <OkObjectResult>();
result.Value.As <IEnumerable <ProfileResult> >().Should().ContainInOrder(expected);
}
}
public void GivenUsersAreConnected_WhenSetupOtherUsersProfileRequested_ReturnCombinedProfilesInPublicMode()
{
// Arrange
var fakeConnection = A.Fake <Connection>();
fakeConnection.UserId = 7;
fakeConnection.OtherUserId = 10;
using (var scope = Container.BeginLifetimeScope())
{
_profilesController = scope.Resolve <ProfilesController>();
var fakeHttpContext = A.Fake <HttpContextBase>();
var session = A.Fake <HttpSessionStateBase>();
session["userId"] = 7;
A.CallTo(() => fakeHttpContext.Session).Returns(session);
ControllerContext context = new ControllerContext(new RequestContext(fakeHttpContext, new RouteData()),
_profilesController);
_profilesController.ControllerContext = context;
// Act
var result = _profilesController.OtherUsersProfile(10) as ViewResult;
// Assert
Assert.IsNotNull(result);
Assert.IsNotNull(result.Model);
Assert.IsInstanceOf <CombinedUserProfilesViewModel>(result.Model);
Assert.That(result.ViewBag.Message, Is.EqualTo("Other User's Profile"));
}
}
public async Task GetProfiles_Returns200_IfProfilesReturnedFromRepo()
{
// Arrange
var mockProfileRepo = new Mock <IRepository <Profile> >();
mockProfileRepo.Setup(i => i.Get()).ReturnsAsync(new List <Profile> {
GetDummyProfile()
});
var controller = new ProfilesController(
mockProfileRepo.Object,
_queryBuilder,
_logger
);
// Act
var response = await controller.Get();
// Assert
var okObjectResult = Assert.IsType <OkObjectResult>(response);
Assert.NotNull(okObjectResult);
Assert.Equal(200, okObjectResult.StatusCode);
var resultValue = Assert.IsType <List <Profile> >(okObjectResult.Value);
Assert.NotNull(resultValue);
Assert.Single(resultValue);
}
public void UpdateProfile_WithNonexistingId_Returns_NotFoundResult()
{
// Arrange
var profileServiceMock = new Mock <IProfileService>();
profileServiceMock.Setup(service => service
.GetProfileByIdAsync(It.IsAny <Guid>()))
.Returns(Task.FromResult(GetNullProfile()));
var loggerMock = new Mock <ILogger>();
loggerMock.Setup(c => c.Warning(It.IsAny <string>()));
var controller = new ProfilesController(profileServiceMock.Object, loggerMock.Object);
var profileDTO = new ProfileDTO {
Id = Guid.Parse("11111111-1111-1111-1111-111111111111")
};
// Act
var result = controller.UpdateProfile(profileDTO).GetAwaiter().GetResult();
// Assert
var notFoundObjectResult = Assert.IsType <NotFoundObjectResult>(result);
Assert.IsAssignableFrom <Guid>(notFoundObjectResult.Value);
}
[HttpGet] ///Todo implement Reservation Validation and Edit View appropriate Preselection of Profiles
public async Task <ActionResult> SelectRoom(int id) // RoomRequest id
{
try
{
using (var db = new ApplicationDbContext())
{
Models.RoomRequest.RoomRequest roomRequest = db.RoomRequests.Find(id);
roomRequest.RoomRequestResponse = await db.RoomRequestResponse.FindAsync(roomRequest.RoomRequestResponse_ID);
Models.VM.ProfilePreviewVM applicantPrevVM = await ProfilesController.ProfilePreviewVM(roomRequest.ApplyingTraveler_ID);
List <Models.RoomRequest.RoomRequest> reservations = await db.RoomRequests.Where(p => p.Request_ID == roomRequest.Request_ID).Include(p => p.RoomRequestResponse).Where(p => p.RoomRequestResponse.responseStatus == Models.RoomRequest.RoomRequestResponseStatus.Reserved).ToListAsync();
Models.Request.Request rq = db.Requests.Where(p => p.ID == roomRequest.Request_ID).Include(p => p.Accommodation).Include(p => p.Accommodation.BedRooms).FirstOrDefault();
Models.RoomRequest.RoomRequestVMOwner applicantVM = new Models.RoomRequest.RoomRequestVMOwner(roomRequest, applicantPrevVM);
Models.Request.SelectRoomVM sRVM = new Models.Request.SelectRoomVM(applicantVM, reservations, rq.Accommodation.BedRooms);
return(View(sRVM));
}
}
catch (Exception e)
{
NotificationManager.AddException(e);
NotificationManager.AddNotification(NotificationType.Error, "Oops, something went wrong!");
return(View());
}
}
public static async Task Returns_updated_profile_after_updating()
{
const string UserId = "User1";
var existingUser = CreateUser.With(userId: UserId);
var mockUserRepository = new Mock <IUserRepository>();
mockUserRepository
.Setup(r => r.GetUser(UserId))
.ReturnsAsync(existingUser);
var request = new ProfilePatchRequest(
alternativeRegistrationNumber: "__NEW_ALTERNATIVE_REG__",
registrationNumber: "__NEW_REG__",
requestReminderEnabled: false,
reservationReminderEnabled: true);
var controller = new ProfilesController(mockUserRepository.Object)
{
ControllerContext = CreateControllerContext.WithUsername(UserId)
};
var result = await controller.PatchAsync(request);
var resultValue = GetResultValue <ProfileResponse>(result);
Assert.NotNull(resultValue.Profile);
Assert.Equal("__NEW_REG__", resultValue.Profile.RegistrationNumber);
Assert.Equal("__NEW_ALTERNATIVE_REG__", resultValue.Profile.AlternativeRegistrationNumber);
Assert.False(resultValue.Profile.RequestReminderEnabled);
Assert.True(resultValue.Profile.ReservationReminderEnabled);
}
public async Task GetProfiles_Returns200_IfProfileIdPresentInRepo()
{
// Arrange
var dummyprofile = GetDummyProfile();
var idOfProfileToGet = dummyprofile.Id;
var mockProfileRepo = new Mock <IRepository <Profile> >();
mockProfileRepo.Setup(i => i.Get(idOfProfileToGet)).ReturnsAsync(dummyprofile);
var controller = new ProfilesController(
mockProfileRepo.Object,
_queryBuilder,
_logger
);
// Act
var response = await controller.Get(idOfProfileToGet);
// Assert
var okObjectResult = Assert.IsType <OkObjectResult>(response);
Assert.NotNull(okObjectResult);
Assert.Equal(200, okObjectResult.StatusCode);
var resultValue = Assert.IsType <Profile>(okObjectResult.Value);
Assert.NotNull(resultValue);
Assert.Equal(idOfProfileToGet, resultValue.Id);
}
public static async Task Returns_profile_for_current_user()
{
var user = CreateUser.With(
userId: "User1",
registrationNumber: "AB123CDE",
alternativeRegistrationNumber: "A999XYZ",
requestReminderEnabled: true,
reservationReminderEnabled: false);
var controller = new ProfilesController(CreateUserRepository.WithUser("User1", user))
{
ControllerContext = CreateControllerContext.WithUsername("User1")
};
var result = await controller.GetAsync();
var resultValue = GetResultValue <ProfileResponse>(result);
Assert.NotNull(resultValue.Profile);
Assert.Equal("AB123CDE", resultValue.Profile.RegistrationNumber);
Assert.Equal("A999XYZ", resultValue.Profile.AlternativeRegistrationNumber);
Assert.True(resultValue.Profile.RequestReminderEnabled);
Assert.False(resultValue.Profile.ReservationReminderEnabled);
}
// GET: Requests/Create //id is roomid likibu
public async Task <ActionResult> Create(string id, string thumb, string Location)
{
try
{
//load Offer from Likibu SearchSession
if (User != null)
{
TravelerProfile tp = await ProfileManager.LoadUserAndTravelerProfile(User);
TravelerProfileSearchSession searchsession = tp.SearchSession; ///searchsession comes here fom view? any has to be saved in loaded TravelerProfile
tp = await ProfilesController.LoadProfile(tp.ID);
tp.SearchSession = searchsession;
Models.Accommodation.Likibu.AccomodationDetailsParam para = new Models.Accommodation.Likibu.AccomodationDetailsParam(tp.Attributes.Language, tp.Attributes.Currency, tp.SearchSession.CheckIn, tp.SearchSession.CheckOut);
Models.Accommodation.Likibu.AccomodationDetails details = await Likibu.LikibuAccess.RequestAccomodationDetails(para, id);
Models.Request.RequestVMOwner requestVM = new Models.Request.RequestVMOwner(details.offer.Destination, details.offer.BedRooms, details.offer.PriceNight, details.offer.PriceWeek, details.offer.PriceMonth, details.offer.Lat, details.offer.Lng, tp.SearchSession.CheckIn, tp.SearchSession.CheckOut, id, tp.Attributes.Currency, thumb);
requestVM.Location = Location;
requestVM.Thumbs = Models.Accommodation.Likibu.Offer.StringToArray(thumb).ToList();
return(View(requestVM));
}
return(View());
}
catch (Exception e)
{
NotificationManager.AddException(e);
NotificationManager.AddNotification(NotificationType.Error, "Oops, something went wrong!");
return(View());
}
}
public async Task CreateProfile_Returns201_IfProfileCreatedInRepo()
{
// Arrange
var dummmyProfile = GetDummyProfile();
var mockProfileRepo = new Mock <IRepository <Profile> >();
mockProfileRepo.Setup(i => i.Create(dummmyProfile)).ReturnsAsync(dummmyProfile);
var controller = new ProfilesController(
mockProfileRepo.Object,
_queryBuilder,
_logger
);
// Act
var response = await controller.Create(dummmyProfile);
// Assert
var createdAtRouteResult = Assert.IsType <CreatedAtRouteResult>(response);;
Assert.NotNull(createdAtRouteResult);
Assert.Equal(201, createdAtRouteResult.StatusCode);
var resultValue = Assert.IsType <Profile>(createdAtRouteResult.Value);;
Assert.NotNull(resultValue);
Assert.Equal(dummmyProfile.Id, resultValue.Id);
}
public void DeleteProfile_WithInvalidModelId_Returns_NotFoundResult()
{
// Arrange
var profileServiceMock = new Mock <IProfileService>();
profileServiceMock.Setup(service => service
.DeleteProfileByIdAsync(It.IsAny <Guid>()))
.Returns(Task.FromResult(false));
var loggerMock = new Mock <ILogger>();
loggerMock.Setup(c => c.Warning(It.IsAny <string>()));
var controller = new ProfilesController(profileServiceMock.Object, loggerMock.Object);
var profileDTO = new ProfileDTO();
var id = new Guid();
// Act
var result = controller.DeleteProfile(id).GetAwaiter().GetResult();
// Assert
var notFoundObjectResult = Assert.IsType <NotFoundObjectResult>(result);
Assert.IsAssignableFrom <Guid>(notFoundObjectResult.Value);
}
public void DeleteProfile_Returns_OkResult()
{
// Arrange
var profileServiceMock = new Mock <IProfileService>();
profileServiceMock.Setup(service => service
.GetProfileByIdAsync(It.IsAny <Guid>()))
.Returns(Task.FromResult(GetProfile()));
profileServiceMock.Setup(service => service
.DeleteProfileByIdAsync(It.IsAny <Guid>()))
.Returns(Task.FromResult(true));
var loggerMock = new Mock <ILogger>();
loggerMock.Setup(c => c.Information(It.IsAny <string>()));
var controller = new ProfilesController(profileServiceMock.Object, loggerMock.Object);
var id = new Guid();
// Act
var result = controller.DeleteProfile(id).GetAwaiter().GetResult();
// Assert
var okObjectResult = Assert.IsType <OkObjectResult>(result);
Assert.IsAssignableFrom <Guid>(okObjectResult.Value);
}
public void UpdateProfile_WithUpdateError_Returns_ConflictResult()
{
// Arrange
var profileServiceMock = new Mock <IProfileService>();
profileServiceMock.Setup(service => service
.GetProfileByIdAsync(It.IsAny <Guid>()))
.Returns(Task.FromResult(GetProfile()));
profileServiceMock.Setup(service => service
.UpdateProfileAsync(It.IsAny <ProfileDTO>()))
.Returns(Task.FromResult(false));
var loggerMock = new Mock <ILogger>();
loggerMock.Setup(c => c.Warning(It.IsAny <string>()));
var controller = new ProfilesController(profileServiceMock.Object, loggerMock.Object);
var profileDTO = new ProfileDTO {
Id = Guid.Parse("11111111-1111-1111-1111-111111111111")
};
// Act
var result = controller.UpdateProfile(profileDTO).GetAwaiter().GetResult();
// Assert
var conflictResult = Assert.IsType <ConflictResult>(result);
}
public void UpdateProfile_WithValidModel_Returns_OkResult()
{
// Arrange
var profileServiceMock = new Mock <IProfileService>();
profileServiceMock.Setup(service => service
.GetProfileByIdAsync(It.IsAny <Guid>()))
.Returns(Task.FromResult(GetProfile()));
profileServiceMock.Setup(service => service
.UpdateProfileAsync(It.IsAny <ProfileDTO>()))
.Returns(Task.FromResult(true));
var loggerMock = new Mock <ILogger>();
loggerMock.Setup(c => c.Information(It.IsAny <string>()));
var controller = new ProfilesController(profileServiceMock.Object, loggerMock.Object);
var profileDTO = new ProfileDTO {
Id = Guid.Parse("11111111-1111-1111-1111-111111111111")
};
// Act
var result = controller.UpdateProfile(profileDTO).GetAwaiter().GetResult();
// Assert
var okResult = Assert.IsType <OkObjectResult>(result);
Assert.IsAssignableFrom <ProfileDTO>(okResult.Value);
}
public async Task <ActionResult> Delete(int?id)
{
if (Check.IsNull(id))
{
return(RedirectToAction("Index"));
}
TravelerProfile travelerProfile = await ProfileManager.LoadUserAndTravelerProfile(User);
using (var db = new ApplicationDbContext())
{
Models.RoomRequest.RoomRequest roomRequest = db.RoomRequests.Find(id);
roomRequest.RoomRequestResponse = db.RoomRequestResponse.Find(roomRequest.RoomRequestResponse_ID);
if (Check.IsNull(roomRequest, "RoomRequest Delete"))
{
return(RedirectToAction("Index"));
}
if (roomRequest.ApplyingTraveler_ID != travelerProfile.ID)
{
NotificationManager.AddException(new Exception("AccessViolation Roomrq Delete"));
return(RedirectToAction("Index"));
}
Models.Request.Request rq = await db.Requests.FindAsync(roomRequest.Request_ID);
rq.Accommodation = await AccommodationsController.LoadAccommodation(rq.Accommodation_ID);
Models.VM.ProfilePreviewVM host = await ProfilesController.ProfilePreviewVM(rq.RequestOwner_ID);
Models.RoomRequest.RoomRequestVMUser roomRequestVM = new Models.RoomRequest.RoomRequestVMUser(roomRequest, rq, host);
return(View(roomRequestVM));
}
}
//GET: RoomRequests/Details/5
public async Task <ActionResult> Details(int id)
{
try
{
using (var db = new ApplicationDbContext())
{
Models.RoomRequest.RoomRequest roomRequest = await db.RoomRequests.FindAsync(id);
roomRequest.RoomRequestResponse = await db.RoomRequestResponse.FindAsync(roomRequest.RoomRequestResponse_ID);
if (Check.IsNull(roomRequest, "DetailsRoomRq"))
{
NotificationManager.AddNotification(NotificationType.Error, "Oops, something went wrong");
return(View());
}
Models.Request.Request rq = await db.Requests.FindAsync(roomRequest.Request_ID);
rq.Accommodation = await AccommodationsController.LoadAccommodation(rq.Accommodation_ID);
Models.VM.ProfilePreviewVM host = await ProfilesController.ProfilePreviewVM(rq.RequestOwner_ID);
Models.RoomRequest.RoomRequestVMUser roomRequestVM = new Models.RoomRequest.RoomRequestVMUser(roomRequest, rq, host);
return(View(roomRequestVM));
}
}
catch (Exception e)
{
NotificationManager.AddException(e);
NotificationManager.AddNotification(NotificationType.Error, "Oops, something went wrong");
return(RedirectToAction("Index", "Home"));
}
}
public async Task <ActionResult> Reservations(int?id) //RequestID
{
try
{
if (!id.HasValue)
{
return(RedirectToAction("Index", "Home"));
}
id = id.Value;
TravelerProfile tp = await ProfileManager.LoadUserAndTravelerProfile(User);
if (Check.IsNull(tp, "Index RoomRequests"))
{
return(RedirectToAction("Index", "Home"));
}
using (var db = new ApplicationDbContext())
{
Models.Request.Request rq = await db.Requests.FindAsync(id);
rq.Accommodation = await AccommodationsController.LoadAccommodation(rq.Accommodation_ID);
IQueryable <Models.RoomRequest.RoomRequest> IQuery = db.RoomRequests.Where(p => p.Request_ID == id).Include(p => p.RoomRequestResponse);
IQueryable <Models.RoomRequest.RoomRequest> Reservations = IQuery.Where(p => p.RoomRequestResponse.responseStatus == Models.RoomRequest.RoomRequestResponseStatus.Reserved);
IQueryable <Models.RoomRequest.RoomRequest> Approvals = IQuery.Where(p => p.RoomRequestResponse.responseStatus == Models.RoomRequest.RoomRequestResponseStatus.Approved);
List <Models.RoomRequest.RoomRequest> ReservationsList = await Reservations.ToListAsync();
List <Models.RoomRequest.RoomRequestVMOwner> resListVM = new List <Models.RoomRequest.RoomRequestVMOwner>();
List <Models.RoomRequest.RoomRequest> ApprovalsList = await Approvals.ToListAsync();
List <Models.RoomRequest.RoomRequestVMOwner> apprListVM = new List <Models.RoomRequest.RoomRequestVMOwner>();
foreach (var res in ReservationsList)
{
Models.VM.ProfilePreviewVM tpVMPrev = await ProfilesController.ProfilePreviewVM(res.ApplyingTraveler_ID);
Models.RoomRequest.RoomRequestVMOwner rRqVM = new Models.RoomRequest.RoomRequestVMOwner(res, tpVMPrev);
resListVM.Add(rRqVM);
}
foreach (var appr in ApprovalsList)
{
Models.VM.ProfilePreviewVM tpVMPrev = await ProfilesController.ProfilePreviewVM(appr.ApplyingTraveler_ID);
Models.RoomRequest.RoomRequestVMOwner rRqVM = new Models.RoomRequest.RoomRequestVMOwner(appr, tpVMPrev);
apprListVM.Add(rRqVM);
}
Models.RoomRequest.ReservationsVM reservationsVM = new Models.RoomRequest.ReservationsVM(rq.Accommodation.BedRooms, resListVM, apprListVM, rq);
return(View(reservationsVM));
}
}
catch (Exception e)
{
NotificationManager.AddException(e);
NotificationManager.AddNotification(NotificationType.Error, "Oops, something went wrong!");
return(View());
}
}
public async Task <ActionResult> Edit(int?id) //id roomRq
{
try
{
if (!id.HasValue)
{
return(RedirectToAction("Search", "Searches"));
}
TravelerProfile travelerProfile = await ProfileManager.LoadUserAndTravelerProfile(User);
using (var db = new ApplicationDbContext())
{
Models.RoomRequest.RoomRequest roomRequest = await db.RoomRequests.FindAsync(id);
if (Check.IsNull(roomRequest, "Edit roomRequest"))
{
return(RedirectToAction("Index"));
}
Models.Request.Request request = await db.Requests.FindAsync(roomRequest.Request_ID);
request.Accommodation = await AccommodationsController.LoadAccommodation(request.Accommodation_ID);
if (!request.IsValid())
{
NotificationManager.AddNotification(NotificationType.Info, "The request is invalid, you can't edit your roomrequest anymore");
return(RedirectToAction("Index"));
}
if (roomRequest.ApplyingTraveler_ID != travelerProfile.ID)
{
NotificationManager.AddException(new Exception("Access violation, this is not your Roomrequest! Edit RoomRequest", new AccessViolationException()));
return(RedirectToAction("Index"));
}
roomRequest.RoomRequestResponse = db.RoomRequestResponse.Find(roomRequest.RoomRequestResponse_ID);
if (roomRequest.RoomRequestResponse.IsApproved())
{
NotificationManager.AddNotification(NotificationType.Info, "You cannot edit an approved roomrequest!");
return(RedirectToAction("Index"));
}
if (roomRequest.RoomRequestResponse.IsReserved())
{
NotificationManager.AddNotification(NotificationType.Info, "You cannot edit a reserved roomrequest!");
return(RedirectToAction("Index"));
}
Models.VM.ProfilePreviewVM host = await ProfilesController.ProfilePreviewVM(request.RequestOwner_ID);
Models.RoomRequest.RoomRequestVMUser roomRequestEditVM = new Models.RoomRequest.RoomRequestVMUser(roomRequest, request, null);
return(View(roomRequestEditVM));
}
}
catch (Exception e)
{
NotificationManager.AddException(e);
return(RedirectToAction("Index"));
}
}
public void SetUp()
{
_fakeProfileService = A.Fake <IProfileService>();
_fakeBookService = A.Fake <IBookService>();
var fakeBookwormDbContext = A.Fake <BookwormDbContext>();
_profilesController = new ProfilesController(_fakeProfileService, _fakeBookService);
_fakeRepository = new Repository <User>(fakeBookwormDbContext);
_mockUserData = new MockUsers();
}
public void TestDeleteOneIDOutOfRange()
{
//Arrange
ProfilesController controller = new ProfilesController();
//Act
StatusCodeResult response = (StatusCodeResult)controller.Delete(8);
//Assert
Assert.AreEqual(response.StatusCode, StatusCodes.Status404NotFound);
}
public void GivenAPlayerNamedNAME(string name)
{
Output.Information($"Create Player {name}");
var model = new ProfileViewModel
{
EmailAddress = EmailAddressFor(name),
DisplayName = name
};
ProfilesController.Create(model);
}
public void Setup()
{
_mocker = AutoMock.GetLoose();
_claimsPrincipal = new ClaimsPrincipalBuilder()
.WithRole(AppRoles.JudgeRole)
.WithClaim(ClaimTypes.GivenName, "John")
.WithClaim(ClaimTypes.Surname, "Doe")
.WithClaim("name", "John D")
.Build();
_sut = SetupControllerWithClaims(_claimsPrincipal);
}
public void Should_return_401_when_exception_thrown()
{
// missing claim will throw an exception
var claimsPrincipal = new ClaimsPrincipalBuilder()
.WithClaim(ClaimTypes.GivenName, "John")
.WithClaim(ClaimTypes.Surname, "Doe")
.Build();
_sut = SetupControllerWithClaims(claimsPrincipal);
var apiException = new UserApiException <ProblemDetails>("Internal Server Error",
(int)HttpStatusCode.InternalServerError,
"Stacktrace goes here", null, default, null);
public void Setup()
{
_userApiClientMock = new Mock <IUserApiClient>();
_mockLogger = new Mock <ILogger <ProfilesController> >();
_claimsPrincipal = new ClaimsPrincipalBuilder()
.WithRole(AppRoles.JudgeRole)
.WithClaim(ClaimTypes.GivenName, "John")
.WithClaim(ClaimTypes.Surname, "Doe")
.WithClaim("name", "John D")
.Build();
_controller = SetupControllerWithClaims(_claimsPrincipal);
}
public async Task <ActionResult> CreateFree(Models.Request.RequestVMFree requestVM)
{
if (ModelState.IsValid)
{
try
{
TravelerProfile tp = await ProfileManager.LoadUserAndTravelerProfile(User);
tp = await ProfilesController.LoadProfile(tp.ID);
Models.Request.Request rq = new Models.Request.Request(tp.ID, requestVM); //AccommodationModel is generated here
rq.Accommodation = new Models.Accommodation.Accommodation(0, requestVM.BedRooms);
if (!rq.Accommodation.Verified)
{
throw new Exception("Accommodation abstraction failed");
}
// get locationIDs
List <Models.Accommodation.Likibu.Destination> dest = await Likibu.LikibuAccess.DestinationRequest(requestVM.Location, tp.Attributes.Language, 1.ToString());
//Models.Accommodation.Likibu.DestinationDetail destDetail = await Likibu.LikibuAccess.DestinationDetailRequest();// Todo add LatLng
rq.Accommodation.AccomProfile = new Models.Accommodation.AccommodationProfile(dest.FirstOrDefault(), requestVM.BedRooms, requestVM.Link);
if (!requestVM.Lat.HasValue || !requestVM.Lng.HasValue)
{
float[] lnglat = new float[2];
lnglat = GoogleWrapper.LongLat2DoubleAr(await GoogleWrapper.GetGeolocation(requestVM.Location));
rq.Accommodation.AccomProfile.Lng = lnglat[0];
rq.Accommodation.AccomProfile.Lat = lnglat[1];
}
else
{
rq.Accommodation.AccomProfile.Lng = requestVM.Lng.Value;
rq.Accommodation.AccomProfile.Lat = requestVM.Lat.Value;
}
using (var db = new ApplicationDbContext())
{
db.Requests.Add(rq);
await db.SaveChangesAsync();
}
NotificationManager.AddNotification(NotificationType.Success, "Your request has been saved!");
return(RedirectToAction("Index", "Home"));
}
catch (Exception e)
{
NotificationManager.AddException(e);
NotificationManager.AddNotification(NotificationType.Error, "Oops, something went wrong!");
}
}
return(View(requestVM));
}
public async Task <ActionResult> Create([Bind(Exclude = "ID")] Models.Request.RequestVMOwner requestVM)
{
if (ModelState.IsValid)
{
try
{
TravelerProfile tp = await ProfileManager.LoadUserAndTravelerProfile(User);
Models.Accommodation.Likibu.AccomodationDetailsParam para = new Models.Accommodation.Likibu.AccomodationDetailsParam(tp.Attributes.Language, tp.Attributes.Currency, requestVM.CheckIn.ToString(), requestVM.CheckOut.ToString());
Models.Accommodation.Likibu.AccomodationDetails details = await Likibu.LikibuAccess.RequestAccomodationDetails(para, requestVM.AccomID);
///
using (var db = new ApplicationDbContext())
{
requestVM.BedRooms = details.offer.BedRooms;
requestVM.Lat = details.offer.Lat;
requestVM.Lng = details.offer.Lng;
requestVM.PricePNight = details.offer.PriceNight.ToString();
requestVM.PricePWeek = details.offer.PriceWeek.ToString();
requestVM.PricepMonth = details.offer.PriceMonth.ToString();
details.offer.Destination = requestVM.Location;
details.offer.Thumbnails = Models.Accommodation.Likibu.Offer.StringToArray(requestVM.ThumbsTemp).ToList();
Models.Request.Request rq = new Models.Request.Request(tp.ID, requestVM);
rq.Accommodation = new Models.Accommodation.Accommodation(details.offer.MaxGuests, details.offer.BedRooms); //AccommodationModel is generated here
if (!rq.Accommodation.Verified)
{
throw new Exception("Accommodation abstraction failed");
}
string currency = ProfilesController.Currency(tp.Attributes.Currency);
rq.Accommodation.AccomProfile = new Models.Accommodation.AccommodationProfile(details.offer, currency);
db.Requests.Add(rq);
await db.SaveChangesAsync();
NotificationManager.AddNotification(NotificationType.Success, "Your Request has been saved!");
return(RedirectToAction("Create", "RoomRequests", new { id = rq.ID }));
}
}
catch (Exception e)
{
NotificationManager.AddException(e);
NotificationManager.AddNotification(NotificationType.Error, "Oops, something went wrong!");
return(RedirectToAction("Search", "Searches"));
}
}
return(View(requestVM));
}
public static async Task Saves_combined_updated_editable_properties_and_existing_readonly_properties()
{
const string UserId = "User1";
var existingUser = CreateUser.With(
userId: UserId,
alternativeRegistrationNumber: "Z999ABC",
commuteDistance: 12.3m,
emailAddress: "*****@*****.**",
firstName: "John",
lastName: "Doe",
registrationNumber: "AB12CDE",
requestReminderEnabled: true,
reservationReminderEnabled: false);
var mockUserRepository = new Mock <IUserRepository>();
mockUserRepository
.Setup(r => r.GetUser(UserId))
.ReturnsAsync(existingUser);
var request = new ProfilePatchRequest(
alternativeRegistrationNumber: "__NEW_ALTERNATIVE_REG__",
registrationNumber: "__NEW_REG__",
requestReminderEnabled: false,
reservationReminderEnabled: true);
var controller = new ProfilesController(mockUserRepository.Object)
{
ControllerContext = CreateControllerContext.WithUsername(UserId)
};
await controller.PatchAsync(request);
mockUserRepository.Verify(r => r.GetUser(UserId), Times.Once);
mockUserRepository.Verify(
r => r.SaveUser(
It.Is <User>(u =>
u.UserId == UserId &&
u.AlternativeRegistrationNumber == "__NEW_ALTERNATIVE_REG__" &&
u.CommuteDistance == 12.3m &&
u.EmailAddress == "*****@*****.**" &&
u.FirstName == "John" &&
u.LastName == "Doe" &&
u.RegistrationNumber == "__NEW_REG__" &&
u.RequestReminderEnabled == false &&
u.ReservationReminderEnabled == true)),
Times.Once);
mockUserRepository.VerifyNoOtherCalls();
}
public void TestGetOneIDOutOfRange()
{
//Arrange
ProfilesController controller = new ProfilesController();
//Act
IActionResult p = controller.Get(650);
StatusCodeResult result = p as StatusCodeResult;
//Assert
Assert.IsNotNull(result);
Assert.AreEqual(result.StatusCode, 404);
}
public void TestGetOne()
{
//Arrange
ProfilesController controller = new ProfilesController();
//Act
IActionResult p = controller.Get(2);
OkObjectResult result = p as OkObjectResult;
//Assert
Assert.IsNotNull(result);
Assert.AreEqual(result.StatusCode, 200);
}
