public async Task <IActionResult> UpdatePushNotification([ModelBinder(typeof(JsonModelBinder <PushNotificationDto>))] Delta <PushNotificationDto> pushNotificationDelta)
{
if (!ModelState.IsValid)
{
return(await Error());
}
var currentPushNotification = _pushNotificationApiService.GetPushNotificationById(pushNotificationDelta.Dto.Id);
if (currentPushNotification == null)
{
return(await Error(HttpStatusCode.NotFound, "push_notification", "not found"));
}
pushNotificationDelta.Merge(currentPushNotification);
//stores
if (pushNotificationDelta.Dto.StoreIds.Count > 0)
{
await AddValidStores(pushNotificationDelta, currentPushNotification);
}
_pushNotificationService.UpdatePushNotification(currentPushNotification);
await UserActivityService.InsertActivityAsync("EditPushNotification", $"Edited a push notification (ID = {currentPushNotification.Id})", currentPushNotification);
var rootObj = new PushNotificationRootObject();
rootObj.PushNotifications.Add(currentPushNotification.ToDto());
var json = JsonFieldsSerializer.Serialize(rootObj, string.Empty);
return(new RawJsonActionResult(json));
}
public async Task <IActionResult> UpdateItem([ModelBinder(typeof(JsonModelBinder <ItemDto>))] Delta <ItemDto> itemDelta)
{
if (!ModelState.IsValid)
{
return(await Error());
}
var currentItem = _itemApiService.GetItemById(itemDelta.Dto.Id);
if (currentItem == null)
{
return(await Error(HttpStatusCode.NotFound, "item", "not found"));
}
itemDelta.Merge(currentItem);
await _itemRepository.UpdateAsync(currentItem);
//activity log
await UserActivityService.InsertActivityAsync("EditItem", $"Edited a item (ID = {currentItem.Id})", currentItem);
var itemDto = currentItem.ToDto();
var itemsRootObject = new ItemsRootObject();
itemsRootObject.Items.Add(itemDto);
var json = JsonFieldsSerializer.Serialize(itemsRootObject, string.Empty);
return(new RawJsonActionResult(json));
}
public async Task <IActionResult> CreateItem([ModelBinder(typeof(JsonModelBinder <ItemDto>))] Delta <ItemDto> itemDelta)
{
if (!ModelState.IsValid)
{
return(await Error());
}
var newItem = new Item();
itemDelta.Merge(newItem);
await _itemRepository.InsertAsync(newItem);
//activity log
await UserActivityService.InsertActivityAsync("AddNewItem", $"Added a new item (ID = {newItem.Id})", newItem);
var newItemDto = newItem.ToDto();
var itemsRootObject = new ItemsRootObject();
itemsRootObject.Items.Add(newItemDto);
var json = JsonFieldsSerializer.Serialize(itemsRootObject, string.Empty);
return(new RawJsonActionResult(json));
}
public static void AddProductToFavorite(int ProductShopID, Guid UserID = new Guid())
{
if (UserID == Guid.Empty && LS.isHaveID())
{
UserID = LS.CurrentUser.ID;
}
if (UserID == Guid.Empty)
{
return;
}
var fav = LS.CurrentEntityContext.ProductFavorites.FirstOrDefault(x => x.ProductShopID == ProductShopID &&
x.UserID == UserID);
if (fav == null)
{
UserActivityService.InsertFavoriteProduct(UserID, ProductShopID, false
, HttpContext.Current.Request.RawUrl,
HttpContext.Current.Request.UrlReferrer != null ? HttpContext.Current.Request.UrlReferrer.OriginalString : null
, LS.GetUser_IP(HttpContext.Current.Request));
fav = new ProductFavorite()
{
CreateDate = DateTime.Now,
ProductShopID = ProductShopID,
UserID = UserID
};
LS.CurrentEntityContext.ProductFavorites.Add(fav);
LS.CurrentEntityContext.SaveChanges();
}
}
public void SelectUptoThreeActivities_Below_Three_Return_False_Test()
{
IUserService _userService = new UserService(_context);
IActivityService _activityService = new ActivityService(_context);
IUserActivityService _userActivityService = new UserActivityService(_context);
ApplicationUser user = new ApplicationUser {
UserName = "******"
};
bool userSaveResult = _userService.AddUser(user);
RecretionalActivity kayaking = new RecretionalActivity {
ActivityName = "Kayaking"
};
_activityService.AddAnActivity(kayaking);
RecretionalActivity camping = new RecretionalActivity {
ActivityName = "Camping"
};
_activityService.AddAnActivity(camping);
if (userSaveResult)
{
_userActivityService.ChooseAnActivity(user, kayaking);
_userActivityService.ChooseAnActivity(user, camping);
}
bool selectUpToThreeActivities = _userActivityService.CanChooseUptoThreeActivities(user);
Assert.IsFalse(selectUpToThreeActivities);
}
public async Task <IActionResult> CreatePushNotification([ModelBinder(typeof(JsonModelBinder <PushNotificationDto>))] Delta <PushNotificationDto> pushNotificationDelta)
{
if (!ModelState.IsValid)
{
return(await Error());
}
var newPushNotification = new PushNotification();
pushNotificationDelta.Merge(newPushNotification);
await _pushNotificationService.InsertPushNotification(newPushNotification);
//stores
if (pushNotificationDelta.Dto.StoreIds.Count > 0)
{
await AddValidStores(pushNotificationDelta, newPushNotification);
_pushNotificationService.UpdatePushNotification(newPushNotification);
}
await UserActivityService.InsertActivityAsync("AddNewPushNotification", $"Added a new push notification (ID = {newPushNotification.Id})", newPushNotification);
var rootObj = new PushNotificationRootObject();
rootObj.PushNotifications.Add(newPushNotification.ToDto());
var json = JsonFieldsSerializer.Serialize(rootObj, string.Empty);
return(new RawJsonActionResult(json));
}
public async Task <IActionResult> UpdateShelfLocation([ModelBinder(typeof(JsonModelBinder <ShelfLocationDto>))] Delta <ShelfLocationDto> shelfLocationDelta)
{
if (!ModelState.IsValid)
{
return(await Error());
}
var currentShelfLocation = _shelfLocationApiService.GetShelfLocationById(shelfLocationDelta.Dto.Id);
if (currentShelfLocation == null)
{
return(await Error(HttpStatusCode.NotFound, "shelf_location", "not found"));
}
shelfLocationDelta.Merge(currentShelfLocation);
await _shelfLocationRepository.UpdateAsync(currentShelfLocation);
await UserActivityService.InsertActivityAsync("EditShelfLocation", $"Edited a shelf location (ID = {currentShelfLocation.Id})", currentShelfLocation);
var shelfLocationDto = currentShelfLocation.ToDto();
var rootObject = new ShelfLocationRootObject();
rootObject.ShelfLocation.Add(shelfLocationDto);
var json = JsonFieldsSerializer.Serialize(rootObject, string.Empty);
return(new RawJsonActionResult(json));
}
public async Task <IActionResult> CreateDevice([ModelBinder(typeof(JsonModelBinder <DeviceDto>))] Delta <DeviceDto> deviceDelta)
{
if (!ModelState.IsValid)
{
return(await Error());
}
var newDevice = _factory.Initialize();
deviceDelta.Merge(newDevice);
await _deviceService.InsertDevice(newDevice);
await UpdateTenantMappings(newDevice, deviceDelta.Dto.TenantIds);
//activity log
await UserActivityService.InsertActivityAsync("AddNewDevice", $"Added a new device (ID = {newDevice.Id})", newDevice);
var newDeviceDto = _dtoHelper.PrepareDeviceDto(newDevice);
var devicesRootObject = new DevicesRootObject();
devicesRootObject.Devices.Add(newDeviceDto);
var json = JsonFieldsSerializer.Serialize(devicesRootObject, string.Empty);
return(new RawJsonActionResult(json));
}
public async Task <IActionResult> CreateShelfLocation([ModelBinder(typeof(JsonModelBinder <ShelfLocationDto>))] Delta <ShelfLocationDto> shelfLocationDelta)
{
if (!ModelState.IsValid)
{
return(await Error());
}
var newShelfLocation = new ShelfLocation();
shelfLocationDelta.Merge(newShelfLocation);
await _shelfLocationRepository.InsertAsync(newShelfLocation);
await UserActivityService.InsertActivityAsync("AddNewShelfLocation", $"Added a new shelf location (ID = {newShelfLocation.Id})", newShelfLocation);
var newShelfLocationDto = newShelfLocation.ToDto();
var rootObject = new ShelfLocationRootObject();
rootObject.ShelfLocation.Add(newShelfLocationDto);
var json = JsonFieldsSerializer.Serialize(rootObject, string.Empty);
return(new RawJsonActionResult(json));
}
public void SetRankAnActivityTest()
{
IUserService _userService = new UserService(_context);
IActivityService _activityService = new ActivityService(_context);
IUserActivityService _userActivityService = new UserActivityService(_context);
ApplicationUser user = new ApplicationUser {
UserName = "******"
};
bool userSaveResult = _userService.AddUser(user);
RecretionalActivity kayaking = new RecretionalActivity {
ActivityName = "Kayaking"
};
_activityService.AddAnActivity(kayaking);
RecretionalActivity camping = new RecretionalActivity {
ActivityName = "Camping"
};
_activityService.AddAnActivity(camping);
if (userSaveResult)
{
_userActivityService.ChooseAnActivity(user, kayaking);
_userActivityService.ChooseAnActivity(user, camping);
}
bool setKayakingAsFiveStarRatingResult = _userActivityService.SetRankAnActivity(user, kayaking, Rating.fiveStar);
bool setCampingAsFourStarRatingResult = _userActivityService.SetRankAnActivity(user, camping, Rating.fourStar);
Assert.IsTrue(setKayakingAsFiveStarRatingResult);
Assert.IsTrue(setCampingAsFourStarRatingResult);
}
public async Task <IActionResult> CreateRole([ModelBinder(typeof(JsonModelBinder <RoleDto>))] Delta <RoleDto> roleDelta)
{
if (!ModelState.IsValid)
{
return(await Error());
}
var newRole = _factory.Initialize();
roleDelta.Merge(newRole);
await UserService.InsertRoleAsync(newRole);
//permission
if (roleDelta.Dto.PermissionIds.Count > 0)
{
await AddValidPermissions(roleDelta, newRole);
await UserService.UpdateRoleAsync(newRole);
}
await UserActivityService.InsertActivityAsync("AddNewRole", $"Added a new role (ID = {newRole.Id})", newRole);
var newRoleDto = newRole.ToDto();
var rootObj = new RolesRootObject();
rootObj.Roles.Add(newRoleDto);
var json = JsonFieldsSerializer.Serialize(rootObj, string.Empty);
return(new RawJsonActionResult(json));
}
public async Task <IActionResult> Validate([FromBody] string rawString)
{
if (string.IsNullOrEmpty(rawString))
{
return(await Error(HttpStatusCode.BadRequest, "payload", "invalid payload"));
}
var validHeader = Request.Headers.TryGetValue("Device-SerialNo", out var val);
if (!validHeader)
{
return(await Error(HttpStatusCode.BadRequest, "serial-no", "invalid header"));
}
var result = await _licenseApiService.ValidateLicense(rawString, val.FirstOrDefault());
if (result != null && result.Length > 0)
{
return(await Error(HttpStatusCode.Unauthorized, "license", string.Join(" ", result)));
}
await UserActivityService.InsertActivityAsync("ValidateLicense", $"Validated license on device (ID = {val.FirstOrDefault()})");
return(Ok(new LicenseRootObject {
IsValid = true
}));
}
private UserActivityService CreateUserActivityService()
{
var userId = Guid.Parse(User.Identity.GetUserId());
var service = new UserActivityService(userId);
return(service);
}
// GET: UserActivity
public ActionResult Index()
{
var userId = Guid.Parse(User.Identity.GetUserId());
var service = new UserActivityService(userId);
var model = service.GetAllUserActivities();
return(View(model));
}
public ActionResult Password()
{
UserActivityService.InsertUserClick(LS.CurrentUser.ID,
Request.RawUrl,
Request.UrlReferrer != null ? Request.UrlReferrer.OriginalString : null
, LS.GetUser_IP(Request));
return(View());
}
public ActionResult _GetShopInfo(int shopID)
{
var culture = new System.Globalization.CultureInfo("he-IL");
var data = LS.GetFirst <Shop>(x => x.ID == shopID);
UserActivityService.InsertShopOpen(LS.CurrentUser.ID, shopID
, Request.RawUrl,
Request.UrlReferrer != null ? Request.UrlReferrer.OriginalString : null
, LS.GetUser_IP(Request));
data.ShopCommentModels = ShoppingService.GetShopComments(shopID);
//data.ShopType = LS.Get<ShopType>()
// .FirstOrDefault(x => data.ShopTypeIDs!= null && data.ShopTypeIDs.Contains(x.ID.ToString() ) );
var curdate = DateTime.Now.Date;
var lastdate = curdate.AddDays(7);
data.WorkTimes = LS.CurrentEntityContext.ShopWorkTimes.Where(x => x.ShopID == shopID && x.Active &&
(!x.IsSpecial || (x.Date >= curdate && x.Date <= lastdate)))
.OrderBy(x => x.IsSpecial).ThenBy(x => x.Day).ThenBy(x => x.Date)
.Select(x => new ShipTimeModel()
{
Date = x.Date,
Day = x.Day,
TimeFromInt = x.TimeFrom,
TimeToInt = x.TimeTo,
IsSpecial = x.IsSpecial,
}).ToList();
foreach (var t in data.WorkTimes)
{
t.DayStr = culture.DateTimeFormat.GetDayName(t.Day);
t.TimeFromeStr = TimeSpan.FromMinutes(t.TimeFromInt).ToString("hh':'mm"); //ntToTime(t.TimeFromInt);
t.TimeToStr = TimeSpan.FromMinutes(t.TimeToInt).ToString("hh':'mm");
t.DateStr = t.Date.ToString("dd/MM");
}
data.ShipTimes = _db.ShopShipTimes.Where(x => x.ShopID == shopID && x.Active && !x.IsSpecial)
.Select(x => new ShipTimeModel()
{
Date = x.Date,
Day = x.Day,
TimeFromInt = x.TimeFrom,
TimeToInt = x.TimeTo,
}).ToList();
foreach (var t in data.ShipTimes)
{
t.DayStr = t.DayStr = culture.DateTimeFormat.GetDayName(t.Day);
t.TimeFromeStr = TimeSpan.FromMinutes(t.TimeFromInt).ToString("hh':'mm");
t.TimeToStr = TimeSpan.FromMinutes(t.TimeToInt).ToString("hh':'mm");
}
if (!string.IsNullOrEmpty(data.Theme))
{
this.HttpContext.Items["ShopTheme"] = data.Theme;
}
return(PartialView("_ShopInfoPopup", data));
}
private async Task LaunchApplicationAsync(string page, object launchParam)
{
Window.Current.Activate();
//{[{
// TODO WTS: This is a sample to demonstrate how to add a UserActivity. Please adapt and move this method call to where you consider convenient in your app.
await UserActivityService.AddSampleUserActivity();
//}]}
}
public void GetTopOneRegionChoosenByTheRegisteredUsersTest()
{
IUserService _userService = new UserService(_context);
IActivityService _activityService = new ActivityService(_context);
IRegionService _regionService = new RegionService(_context);
IUserActivityService _userActivityService = new UserActivityService(_context);
// Region
Region bd = new Region {
RegionName = "Bangladesh"
};
Region usa = new Region {
RegionName = "USA"
};
Region canada = new Region {
RegionName = "Canada"
};
_regionService.AddRegion(bd);
_regionService.AddRegion(usa);
_regionService.AddRegion(canada);
ApplicationUser test = new ApplicationUser {
UserName = "******", Region = bd
};
ApplicationUser alif = new ApplicationUser {
UserName = "******", Region = usa
};
ApplicationUser hamza = new ApplicationUser {
UserName = "******", Region = canada
};
ApplicationUser kabir = new ApplicationUser {
UserName = "******", Region = bd
};
ApplicationUser saif = new ApplicationUser {
UserName = "******", Region = canada
};
ApplicationUser salman = new ApplicationUser {
UserName = "******", Region = bd
};
_userService.AddUser(test);
_userService.AddUser(alif);
_userService.AddUser(hamza);
_userService.AddUser(kabir);
_userService.AddUser(saif);
_userService.AddUser(salman);
var topRegion = _userActivityService.GetTopFiveRegionChoosenByTheRegisteredUsers().FirstOrDefault();
Assert.IsNotNull(topRegion);
Assert.AreEqual(bd.RegionName, topRegion.Region.RegionName);
}
public async Task GetById_EmptyId_ArgumentException()
{
var repository = new Mock <IUserActivityRepository>();
repository.Setup(r => r.GetById(It.IsAny <string>()))
.ReturnsAsync(It.IsAny <UserActivity>());
var service = new UserActivityService(repository.Object);
await Assert.ThrowsAsync <ArgumentNullException>(() => service.GetById(string.Empty));
}
public async Task <IActionResult> CreateUser([ModelBinder(typeof(JsonModelBinder <UserDto>))] Delta <UserDto> userDelta)
{
if (!ModelState.IsValid)
{
return(await Error());
}
var newUser = _factory.Initialize();
userDelta.Merge(newUser);
await UserService.InsertUserAsync(newUser);
await InsertFirstAndLastNameGenericAttributes(userDelta.Dto.FirstName, userDelta.Dto.LastName, newUser);
//password
if (!string.IsNullOrWhiteSpace(userDelta.Dto.Password))
{
await AddPassword(userDelta.Dto.Password, newUser);
}
//roles
if (userDelta.Dto.RoleIds.Count > 0)
{
AddValidRoles(userDelta, newUser);
}
//stores
if (userDelta.Dto.StoreIds.Count > 0)
{
await AddValidStores(userDelta, newUser);
}
await UserService.UpdateUserAsync(newUser);
var newUserDto = newUser.ToDto();
newUserDto.FirstName = userDelta.Dto.FirstName;
newUserDto.LastName = userDelta.Dto.LastName;
newUserDto.UserPassword = _userApiService.GetUserPassword(newUserDto.Id);
//activity log
await UserActivityService.InsertActivityAsync("AddNewUser", $"Added a new user (ID = {newUser.Id})", newUser);
var usersRootObject = new UsersRootObject();
usersRootObject.Users.Add(newUserDto);
var json = JsonFieldsSerializer.Serialize(usersRootObject, string.Empty);
return(new RawJsonActionResult(json));
}
public async Task GetById_NonExistingDocumentId_Null()
{
var repository = new Mock <IUserActivityRepository>();
repository.Setup(r => r.GetById("5e1b9429757df200173c6c36"))
.ReturnsAsync(new UserActivity("buy", "2016-09-22T13:57:31.2311892-04:00"));
var service = new UserActivityService(repository.Object);
var document = await service.GetById("999999999999999999999999");
Assert.Null(document);
}
public async Task Create_NullObject_ArgumentNullException()
{
var repository = new Mock <IUserActivityRepository>();
var expectedDocumentId = "5e1b9429757df200173c6c36";
repository.Setup(r => r.Create(It.IsAny <UserActivity>())).ReturnsAsync(expectedDocumentId);
var service = new UserActivityService(repository.Object);
await Assert.ThrowsAsync <ArgumentNullException>(() =>
service.Create(null));
}
public ActionResult DiscountHistory()
{
UserActivityService.InsertUserClick(LS.CurrentUser.ID,
Request.RawUrl,
Request.UrlReferrer != null ? Request.UrlReferrer.OriginalString : null
, LS.GetUser_IP(Request));
if (!LS.isHaveID())
{
return(Redirect("~/"));
}
var model = LS.CurrentUser;
return(View(model));
}
public async Task GetAll_Returns_AllUserActivities()
{
var repository = new Mock <IUserActivityRepository>();
repository.Setup(r => r.GetAll()).ReturnsAsync(new List <UserActivity> {
new UserActivity("buy", "2016-09-22T13:57:31.2311892-04:00"),
new UserActivity("click", "2016-09-23T22:50:11.2311892-04:00"),
new UserActivity("scroll", "2016-08-30T12:11:22.5671892-04:00"),
});
var service = new UserActivityService(repository.Object);
var result = await service.GetAll();
Assert.Equal(3, result.ToList().Count);
}
public async Task Create_EmptyTimeStamp_ArgumentException()
{
var repository = new Mock <IUserActivityRepository>();
var expectedDocumentId = "5e1b9429757df200173c6c36";
repository.Setup(r => r.Create(It.IsAny <UserActivity>())).ReturnsAsync(expectedDocumentId);
var service = new UserActivityService(repository.Object);
await Assert.ThrowsAsync <ArgumentException>(() =>
service.Create(new UserActivityRequest {
Event = "buy", TimeStamp = string.Empty
}));
}
private void CreateServices()
{
QuizService = new QuizService(QuizRepo, QuizRatingRepo);
QuestionService = new QuestionService(QuestionRepo);
AnswerService = new AnswerService(AnswerRepo);
QuizCategoryService = new QuizCategoryService(QuizCategoryRepo);
QuizResultService = new QuizResultService(QuizRepo, QuizResultRepo, QuizRatingRepo, QuestionRepo, AnswerRepo);
UserActivityService = new UserActivityService(UserActivityRepo, QuizRepo, QuestionRepo);
ModelConverter = new ModelConverter(
QuizCategoryService, QuizResultService, AnswerService, QuestionService, QuizService);
ViewModelConverter = new ViewModelConverter(
QuizService, AnswerService, QuestionService, QuizCategoryService);
}
public ActionResult Index()
{
UserActivityService.InsertUserClick(LS.CurrentUser.ID,
Request.RawUrl,
Request.UrlReferrer != null ? Request.UrlReferrer.OriginalString : null
, LS.GetUser_IP(Request));
if (!LS.isHaveID())
{
return(Redirect("~/Account/LogOn"));
}
var model = LS.CurrentUser;
return(View("Orders", model));
}
public async Task <IActionResult> UpdateDeviceByAttributes([FromQuery] int id, [FromQuery] string serialno, [ModelBinder(typeof(JsonModelBinder <DeviceDto>))] Delta <DeviceDto> deviceDelta)
{
if (!ModelState.IsValid)
{
return(await Error());
}
Device currentDevice;
if (id > 0)
{
currentDevice = _deviceApiService.GetDeviceById(id);
}
else if (!string.IsNullOrEmpty(serialno))
{
currentDevice = _deviceApiService.GetDeviceBySerialNo(serialno);
}
else
{
return(await Error(HttpStatusCode.BadRequest, "invalid", "invalid id or serial_no"));
}
if (currentDevice == null)
{
return(await Error(HttpStatusCode.NotFound, "device", "not found"));
}
deviceDelta.Merge(currentDevice);
currentDevice.ModifiedOnUtc = DateTime.UtcNow;
_deviceService.UpdateDevice(currentDevice);
await UpdateTenantMappings(currentDevice, deviceDelta.Dto.TenantIds);
await UserActivityService.InsertActivityAsync("EditDevice",
$"Edited a device (ID = {currentDevice.Id}, SN = {currentDevice.SerialNo})", currentDevice);
var deviceDto = _dtoHelper.PrepareDeviceDto(currentDevice);
var devicesRootObject = new DevicesRootObject();
devicesRootObject.Devices.Add(deviceDto);
var json = JsonFieldsSerializer.Serialize(devicesRootObject, string.Empty);
return(new RawJsonActionResult(json));
}
public async Task Create_NullEvent_ArgumentException()
{
var repository = new Mock <IUserActivityRepository>();
var expectedDocumentId = "5e1b9429757df200173c6c36";
repository.Setup(r => r.Create(It.IsAny <UserActivity>())).ReturnsAsync(expectedDocumentId);
var service = new UserActivityService(repository.Object);
await Assert.ThrowsAsync <ArgumentException>(() =>
service.Create(new UserActivityRequest
{
Event = null,
TimeStamp = "2016-09-22T13:57:31.2311892-04:00"
}));
}
public void FetchLogPage_Test()
{
//Arange
const int pageCount = 50;
var stubLogFactory = new Mock <IPrompterDiagnosticsDbContextFactory>();
var stubLogContext = new Mock <IPrompterDiagnosticsDbContext>();
stubLogFactory.Setup(l => l.Create())
.Returns(stubLogContext.Object);
var logs = new List <UserActivity>(pageCount * 2);
for (int i = 0; i < pageCount * 2; i++)
{
logs.Add(new UserActivity());
}
var contextLogs = logs.AsQueryable();
stubLogContext.Setup(c => c.UserActivities.GetEnumerator())
.Returns(contextLogs.GetEnumerator());
stubLogContext.Setup(c => c.UserActivities.Provider)
.Returns(contextLogs.Provider);
stubLogContext.Setup(c => c.UserActivities.Expression)
.Returns(contextLogs.Expression);
var service = new UserActivityService(stubLogFactory.Object);
//Act
var actual = service.FetchLogPage(1);
//Assert
stubLogFactory.Verify(f => f.Create(),
Times.Once);
stubLogContext.Verify(c => c.UserActivities,
Times.Once);
Assert.That(actual.Count == pageCount);
Assert.That(service.FetchLogPage(2)
.Count == pageCount);
Assert.That(service.FetchLogPage(3)
.Count == 0);
}
