public ChallengeService(ILogger <ChallengeService> logger,
GRA.Abstract.IDateTimeProvider dateTimeProvider,
IUserContextProvider userContextProvider,
IBadgeRepository badgeRepository,
IBranchRepository branchRepository,
ICategoryRepository categoryRepository,
IChallengeRepository challengeRepository,
IChallengeGroupRepository challengeGroupRepository,
IChallengeTaskRepository challengeTaskRepository,
IEventRepository eventRepository,
IPathResolver pathResolver,
ITriggerRepository triggerRepository,
IUserRepository userRepository) : base(logger, dateTimeProvider, userContextProvider)
{
_badgeRepository = Require.IsNotNull(badgeRepository, nameof(badgeRepository));
_branchRepository = Require.IsNotNull(branchRepository, nameof(branchRepository));
_categoryRepository = Require.IsNotNull(categoryRepository, nameof(categoryRepository));
_challengeRepository = Require.IsNotNull(challengeRepository,
nameof(challengeRepository));
_challengeGroupRepository = Require.IsNotNull(challengeGroupRepository,
nameof(challengeGroupRepository));
_challengeTaskRepository = Require.IsNotNull(challengeTaskRepository,
nameof(challengeTaskRepository));
_eventRepository = Require.IsNotNull(eventRepository, nameof(eventRepository));
_pathResolver = Require.IsNotNull(pathResolver, nameof(pathResolver));
_triggerRepository = Require.IsNotNull(triggerRepository, nameof(triggerRepository));
_userRepository = Require.IsNotNull(userRepository, nameof(userRepository));
}
public ActivityService(ILogger <UserService> logger,
IUserContextProvider userContext,
IBadgeRepository badgeRepository,
IBookRepository bookRepository,
IChallengeRepository challengeRepository,
INotificationRepository notificationRepository,
IPointTranslationRepository pointTranslationRepository,
IProgramRepository programRepository,
ITriggerRepository triggerRepository,
IUserRepository userRepository,
IUserLogRepository userLogRepository,
IVendorCodeRepository vendorCodeRepository,
IVendorCodeTypeRepository vendorCodeTypeRepository,
MailService mailService) : base(logger, userContext)
{
_badgeRepository = Require.IsNotNull(badgeRepository, nameof(badgeRepository));
_bookRepository = Require.IsNotNull(bookRepository, nameof(bookRepository));
_challengeRepository = Require.IsNotNull(challengeRepository,
nameof(challengeRepository));
_notificationRepository = Require.IsNotNull(notificationRepository,
nameof(notificationRepository));
_pointTranslationRepository = Require.IsNotNull(pointTranslationRepository,
nameof(pointTranslationRepository));
_programRepository = Require.IsNotNull(programRepository, nameof(programRepository));
_triggerRepository = Require.IsNotNull(triggerRepository, nameof(triggerRepository));
_userRepository = Require.IsNotNull(userRepository, nameof(userRepository));
_userLogRepository = Require.IsNotNull(userLogRepository,
nameof(userLogRepository));
_vendorCodeRepository = Require.IsNotNull(vendorCodeRepository,
nameof(vendorCodeRepository));
_vendorCodeTypeRepository = Require.IsNotNull(vendorCodeTypeRepository,
nameof(vendorCodeTypeRepository));
_mailService = Require.IsNotNull(mailService, nameof(mailService));
}
public QuestionnaireService(ILogger <QuestionnaireService> logger,
GRA.Abstract.IDateTimeProvider dateTimeProvider,
IUserContextProvider userContextProvider,
IAnswerRepository answerRepository,
IBadgeRepository badgeRepository,
INotificationRepository notificationRepository,
IQuestionRepository questionRepository,
IQuestionnaireRepository questionnaireRepository,
IRequiredQuestionnaireRepository requiredQuestionnaireRepository,
IUserLogRepository userLogRepository)
: base(logger, dateTimeProvider, userContextProvider)
{
SetManagementPermission(Permission.ManageQuestionnaires);
_answerRepository = answerRepository
?? throw new ArgumentNullException(nameof(answerRepository));
_badgeRepository = badgeRepository
?? throw new ArgumentNullException(nameof(badgeRepository));
_notificationRepository = notificationRepository
?? throw new ArgumentNullException(nameof(notificationRepository));
_questionRepository = questionRepository
?? throw new ArgumentNullException(nameof(questionRepository));
_questionnaireRepository = questionnaireRepository
?? throw new ArgumentNullException(nameof(questionnaireRepository));
_requiredQuestionnaireRepository = requiredQuestionnaireRepository
?? throw new ArgumentNullException(nameof(requiredQuestionnaireRepository));
_userLogRepository = userLogRepository
?? throw new ArgumentNullException(nameof(userLogRepository));
}
public void UserVoteUpAwardBadge2()
{
_badgeRepository = Substitute.For <IBadgeRepository>();
_badgeService = new BadgeService(_badgeRepository, _api, _loggingService, _localizationService, _activityService);
// Create a user with two votes no badges - will create a badge because no previous badge
var user = new MembershipUser
{
Votes = new List <Vote>
{
new Vote {
Id = Guid.NewGuid()
},
new Vote {
Id = Guid.NewGuid()
}
},
Badges = new List <Badge>(),
BadgeTypesTimeLastChecked = new List <BadgeTypeTimeLastChecked>
{
new BadgeTypeTimeLastChecked
{
BadgeType = BadgeType.VoteUp.ToString(), TimeLastChecked = GetTimeAllowsBadgeUpdate()
}
}
};
_badgeRepository.Get(Arg.Any <Guid>()).Returns(new Badge {
Name = "UserVoteUp"
});
_badgeService.ProcessBadge(BadgeType.VoteUp, user);
Assert.IsTrue(user.Badges.Count == 1);
Assert.IsTrue(user.Badges[0].Name == "UserVoteUp");
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="activityRepository"> </param>
/// <param name="badgeRepository"> </param>
/// <param name="membershipRepository"> </param>
/// <param name="loggingService"> </param>
public ActivityService(IActivityRepository activityRepository, IBadgeRepository badgeRepository, IMembershipRepository membershipRepository, ILoggingService loggingService)
{
_activityRepository = activityRepository;
_badgeRepository = badgeRepository;
_loggingService = loggingService;
_membershipRepository = membershipRepository;
}
public void SyncBadgesUpdateBadgeRecords()
{
_badgeRepository = Substitute.For <IBadgeRepository>();
_badgeService = new BadgeService(_badgeRepository, _api, _loggingService, _localizationService, _activityService);
var badgeInDb = new Badge
{
Id = new Guid(GuidTestVoteUp),
Name = "XXX",
DisplayName = "XXX",
Description = "XXX",
Image = "XXX"
};
var badgesInDbAlready = new List <Badge>
{
badgeInDb
};
_badgeRepository.GetAll().Returns(badgesInDbAlready);
_badgeService.SyncBadges();
// The test badge class has been identified as the same badge as found in the "database", so that database
// badge's fields have been updated with the test badge class's attributes
Assert.IsTrue(badgeInDb.Name == NameTestVoteUp);
Assert.IsTrue(badgeInDb.Description == DescriptionTestVoteUp);
Assert.IsTrue(badgeInDb.DisplayName == DisplayNameTestVoteUp);
Assert.IsTrue(badgeInDb.Image == ImageTestVoteUp);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="activityRepository"> </param>
/// <param name="badgeRepository"> </param>
/// <param name="membershipRepository"> </param>
/// <param name="loggingService"> </param>
public ActivityService(IActivityRepository activityRepository, IBadgeRepository badgeRepository, IMembershipRepository membershipRepository, ILoggingService loggingService)
{
_activityRepository = activityRepository;
_badgeRepository = badgeRepository;
_loggingService = loggingService;
_membershipRepository = membershipRepository;
}
public void PosterVoteUpRefuseBadge_TooSoon()
{
_badgeRepository = Substitute.For <IBadgeRepository>();
_badgeService = new BadgeService(_badgeRepository, _api, _loggingService, _localizationService, _activityService);
// Create a user with one post with one vote
var post = new Post
{
Id = Guid.NewGuid(),
Votes = new List <Vote> {
new Vote {
Id = Guid.NewGuid()
}
},
};
var user = new MembershipUser
{
Posts = new List <Post> {
post
},
Badges = new List <Badge>(),
BadgeTypesTimeLastChecked = new List <BadgeTypeTimeLastChecked>
{
new BadgeTypeTimeLastChecked
{
BadgeType = BadgeType.VoteUp.ToString(), TimeLastChecked = GetTimeDisAllowsBadgeUpdate()
}
}
};
_badgeService.ProcessBadge(BadgeType.VoteUp, user);
Assert.IsTrue(user.Badges.Count == 0);
}
public void AnniversaryTimeAwardBadge()
{
_badgeRepository = Substitute.For <IBadgeRepository>();
_api.Topic = Substitute.For <ITopicAPI>();
_badgeService = new BadgeService(_badgeRepository, _api, _loggingService, _localizationService, _activityService);
var now = DateTime.UtcNow;
var user = new MembershipUser
{
CreateDate = new DateTime(now.Year - 1, now.Month, now.Day),
Badges = new List <Badge>(),
BadgeTypesTimeLastChecked = new List <BadgeTypeTimeLastChecked>
{
new BadgeTypeTimeLastChecked
{
BadgeType = BadgeType.VoteUp.ToString(), TimeLastChecked = GetTimeAllowsBadgeUpdate()
}
}
};
_badgeRepository.Get(Arg.Any <Guid>()).Returns(new Badge {
Name = "MemberForAYear"
});
_badgeService.ProcessBadge(BadgeType.Time, user);
Assert.IsTrue(user.Badges.Count == 1);
Assert.IsTrue(user.Badges[0].Name == "MemberForAYear");
}
public void UserAlreadyHasBadge()
{
_badgeRepository = Substitute.For <IBadgeRepository>();
_badgeService = new BadgeService(_badgeRepository, _api, _loggingService, _localizationService, _activityService);
// Create a user with one vote no badges
var user = new MembershipUser
{
Votes = new List <Vote>
{
new Vote {
Id = Guid.NewGuid()
}
},
Badges = new List <Badge>(),
BadgeTypesTimeLastChecked = new List <BadgeTypeTimeLastChecked>
{
new BadgeTypeTimeLastChecked
{
BadgeType = BadgeType.VoteUp.ToString(), TimeLastChecked = GetTimeAllowsBadgeUpdate()
}
}
};
// Call twice but only one badge awarded
_badgeRepository.Get(Arg.Any <Guid>()).Returns(new Badge {
Name = "testbadge"
});
_badgeService.ProcessBadge(BadgeType.VoteUp, user);
_badgeService.ProcessBadge(BadgeType.VoteUp, user);
Assert.IsTrue(user.Badges.Count == 1);
}
public BadgesController(IBadgeRepository repository,
ILogger <BadgesController> logger, IMapper mapper)
{
this.repository = repository;
this.logger = logger;
this.mapper = mapper;
}
public void SyncBadgesDeleteOldBadgeRecords()
{
_badgeRepository = Substitute.For <IBadgeRepository>();
_badgeService = new BadgeService(_badgeRepository, _api, _loggingService, _localizationService, _activityService);
var badgesInDbAlready = new List <Badge>
{
new Badge
{
Id = new Guid("2ac1fc11-2f9e-4d5a-9df4-29715f10b6d1"),
Name = "PosterVoteUp"
},
new Badge
{
Id = new Guid("2ac1fc11-2f9e-4d5a-9df4-29715f10b6d2"),
Name = "BadgeWithNoMatchingClass"
}
};
_badgeRepository.GetAll().Returns(badgesInDbAlready);
_badgeService.SyncBadges();
_badgeRepository.Received().Delete(Arg.Is <Badge>(x => x.Name == "BadgeWithNoMatchingClass"));
}
public BadgeLogic(IBadgeRepository badgeRepository,
IMapper mapper,
IHttpContextAccessor contextAccessor)
{
_badgeRepository = badgeRepository;
_mapper = mapper;
_contextAccessor = contextAccessor;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="badgeRepository"> </param>
/// <param name="api"></param>
/// <param name="loggingService"> </param>
/// <param name="localizationService"> </param>
/// <param name="activityService"> </param>
public BadgeService(IBadgeRepository badgeRepository,
ILoggingService loggingService, ILocalizationService localizationService, IActivityService activityService)
{
_badgeRepository = badgeRepository;
_loggingService = loggingService;
_localizationService = localizationService;
_activityService = activityService;
}
public ExperienceService(IExperienceRepository repository,
IBadgeRepository badgeRepository,
IMapper mapper)
{
_repository = repository;
_badgeRepository = badgeRepository;
_mapper = mapper;
}
private static bool isDominating(Guid user_id, IBadgeRepository badgeRepo, int CurrentStreak)
{
if (isDuplicate(user_id, "Dominating", badgeRepo) != true && CurrentStreak == 4)
{
return(true);
}
return(false);
}
public BadgeServices(IBadgeRepository BadgeRepository)
{
if (BadgeRepository == null)
{
throw new ArgumentNullException("BadgeRepository");
}
this.badgeRepository = BadgeRepository;
}
public HomeController(IBadgeRepository ibadgeRepository, IPostRepository ipostRepository
, ITagRepository itagRepository, IUserRepository iuserRepository)
{
this.ibadgeRepository = ibadgeRepository;
this.ipostRepository = ipostRepository;
this.itagRepository = itagRepository;
this.iuserRepository = iuserRepository;
}
public BadgeService(ILogger <BadgeService> logger,
IUserContextProvider userContextProvider,
IConfigurationRoot config,
IBadgeRepository badgeRepository) : base(logger, userContextProvider)
{
_badgeRepository = Require.IsNotNull(badgeRepository, nameof(badgeRepository));
_config = Require.IsNotNull(config, nameof(config));
}
public void UserVoteUpAwardBadgeTwoUsers()
{
// Useful for testing badge service internal badge class instance cache is called
_badgeRepository = Substitute.For <IBadgeRepository>();
_badgeService = new BadgeService(_badgeRepository, _api, _loggingService, _localizationService, _activityService);
// Create a user with one vote no badges, set time checking offset to be safe so badge will be processed
var user1 = new MembershipUser
{
Votes = new List <Vote>
{
new Vote {
Id = Guid.NewGuid()
}
},
Badges = new List <Badge>(),
BadgeTypesTimeLastChecked = new List <BadgeTypeTimeLastChecked>
{
new BadgeTypeTimeLastChecked
{
BadgeType = BadgeType.VoteUp.ToString(), TimeLastChecked = GetTimeAllowsBadgeUpdate()
}
}
};
// Create a user with one vote no badges, set time checking offset to be safe so badge will be processed
var user2 = new MembershipUser
{
Votes = new List <Vote>
{
new Vote {
Id = Guid.NewGuid()
}
},
Badges = new List <Badge>(),
BadgeTypesTimeLastChecked = new List <BadgeTypeTimeLastChecked>
{
new BadgeTypeTimeLastChecked
{
BadgeType = BadgeType.VoteUp.ToString(), TimeLastChecked = GetTimeAllowsBadgeUpdate()
}
}
};
_badgeRepository.Get(Arg.Any <Guid>()).Returns(new Badge {
Name = "UserVoteUp"
});
_badgeService.ProcessBadge(BadgeType.VoteUp, user1);
_badgeService.ProcessBadge(BadgeType.VoteUp, user2);
Assert.IsTrue(user1.Badges.Count == 1);
Assert.IsTrue(user1.Badges[0].Name == "UserVoteUp");
Assert.IsTrue(user2.Badges.Count == 1);
Assert.IsTrue(user2.Badges[0].Name == "UserVoteUp");
}
public AttainmentLogic(IUnitOfWork unit, IAttainmentRepository repo, IBadgeRepository b, IActivityRepository a, ITargetRepository t, ITeamLogic teamLogic)
{
this.Unit = unit;
this.Repo = repo;
this.bRepo = b;
this.actRepo = a;
this.tRepo = t;
this.teamLogic = teamLogic;
}
/// <summary>
/// Constructor takes three parameters and is handled automatically by ASP.NET
/// </summary>
/// <param name="poc">Constructor injection done by Services Providers</param>
/// <param name="animalRepo">Constructor injection done by Services Providers</param>
/// <param name="badgeRepository">Constructor injection done by Services Providers</param>
/// <param name="eggRepo">Constructor injection done by Services Providers</param>
public AnimalsController(IPetOwnerRepository poc, IAnimalRepository animalRepo,
IBadgeRepository badgeRepository, IEggRepository eggRepo, IItemRepository itemRepo)
{
_poc = poc;
_animalRepo = animalRepo;
_badgeRepo = badgeRepository;
_eggRepo = eggRepo;
_itemRepo = itemRepo;
}
public FeedEventService(IFeedEventRepository feedEventRepository, IMembershipRepository membershipRepository, IMoodRepository moodRepository, IGroupRepository groupRepository, IBadgeRepository badgeRepository, IUnitOfWork unit)
{
_feedEventRepository = feedEventRepository;
_membershipRepository = membershipRepository;
_moodRepository = moodRepository;
_groupRepository = groupRepository;
_badgeRepository = badgeRepository;
_unit = unit;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="badgeRepository"> </param>
/// <param name="api"></param>
/// <param name="loggingService"> </param>
/// <param name="localizationService"> </param>
/// <param name="activityService"> </param>
public BadgeService(IBadgeRepository badgeRepository, IMVCForumAPI api,
ILoggingService loggingService, ILocalizationService localizationService, IActivityService activityService)
{
_badgeRepository = badgeRepository;
_mvcForumAPI = api;
_loggingService = loggingService;
_localizationService = localizationService;
_activityService = activityService;
}
public AttainmentLogic(IUnitOfWork unit, IAttainmentRepository repo, IBadgeRepository b, IActivityRepository a, ITargetRepository t, ITeamLogic teamLogic)
{
this.Unit = unit;
this.Repo = repo;
this.bRepo = b;
this.actRepo = a;
this.tRepo = t;
this.teamLogic = teamLogic;
}
public void SyncBadgesCreateNewBadgeRecords()
{
_badgeRepository = Substitute.For <IBadgeRepository>();
_badgeService = new BadgeService(_badgeRepository, _api, _loggingService, _localizationService, _activityService);
_badgeService.SyncBadges();
_badgeRepository.Received().Add(Arg.Is <Badge>(x => x.Name == "PosterVoteUp" &&
x.Id.ToString() == "2ac1fc11-2f9e-4d5a-9df4-29715f10b6d1" &&
x.Image == "PosterVoteUpBadge.png" &&
x.Description == "This badge is awarded to users after they receive their first vote up from another user."));
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="badgeRepository"> </param>
/// <param name="api"></param>
/// <param name="loggingService"> </param>
/// <param name="localizationService"> </param>
/// <param name="activityService"> </param>
public BadgeService(IBadgeRepository badgeRepository,
ILoggingService loggingService, ILocalizationService localizationService, IActivityService activityService, IMembershipUserPointsService membershipUserPointsService, IReflectionService reflectionService)
{
_badgeRepository = badgeRepository;
_loggingService = loggingService;
_localizationService = localizationService;
_activityService = activityService;
_membershipUserPointsService = membershipUserPointsService;
_reflectionService = reflectionService;
}
public void MarkAsSolutionAwardTwoBadges()
{
_badgeRepository = Substitute.For <IBadgeRepository>();
_api.Topic = Substitute.For <ITopicAPI>();
_badgeService = new BadgeService(_badgeRepository, _api, _loggingService, _localizationService, _activityService);
// Create a user with one topic marked as solved
var id = Guid.NewGuid();
var user = new MembershipUser
{
Id = id,
Badges = new List <Badge>(),
BadgeTypesTimeLastChecked = new List <BadgeTypeTimeLastChecked>
{
new BadgeTypeTimeLastChecked
{
BadgeType = BadgeType.VoteUp.ToString(), TimeLastChecked = GetTimeAllowsBadgeUpdate()
}
}
};
var listPostsForMember = new List <Post> {
new Post
{
User = new MembershipUser
{
Id = user.Id,
Badges = new List <Badge>()
},
},
};
var listTopicsForMember = new List <Topic>
{
new Topic
{
Solved = true,
User = new MembershipUser
{
Id = user.Id,
Badges = new List <Badge>()
},
},
};
_api.Topic.GetSolvedTopicsByMember(id).Returns(listTopicsForMember);
_api.Post.GetSolutionsWrittenByMember(id).Returns(listPostsForMember);
_badgeRepository.Get(Arg.Any <Guid>()).Returns(new Badge {
Name = "testbadge"
});
_badgeService.ProcessBadge(BadgeType.MarkAsSolution, user);
Assert.IsTrue(user.Badges.Count == 2);
}
public VehicleController(IVehicleRepository vehicleRepository,
IUnitOfWork unitOfWork,
IMakeRepository makeRepository,
IModelRepository modelRepository,
IBadgeRepository badgeRepository) : base(unitOfWork)
{
_vehicleRepository = vehicleRepository;
_makeRepository = makeRepository;
_modelRepository = modelRepository;
_badgeRepository = badgeRepository;
}
public BadgeService(ILogger <BadgeService> logger,
GRA.Abstract.IDateTimeProvider dateTimeProvider,
IUserContextProvider userContextProvider,
IConfigurationRoot config,
IBadgeRepository badgeRepository,
IPathResolver pathResolver) : base(logger, dateTimeProvider, userContextProvider)
{
_config = Require.IsNotNull(config, nameof(config));
_badgeRepository = Require.IsNotNull(badgeRepository, nameof(badgeRepository));
_pathResolver = Require.IsNotNull(pathResolver, nameof(pathResolver));
}
public BadgeService(ILogger <BadgeService> logger,
GRA.Abstract.IDateTimeProvider dateTimeProvider,
IUserContextProvider userContextProvider,
IBadgeRepository badgeRepository,
IPathResolver pathResolver,
SiteLookupService siteLookupService) : base(logger, dateTimeProvider, userContextProvider)
{
_badgeRepository = Require.IsNotNull(badgeRepository, nameof(badgeRepository));
_pathResolver = Require.IsNotNull(pathResolver, nameof(pathResolver));
_siteLookupService = siteLookupService
?? throw new ArgumentNullException(nameof(siteLookupService));
}
public UserService(ILogger <UserService> logger,
IUserContextProvider userContextProvider,
GRA.Abstract.IPasswordValidator passwordValidator,
IAuthorizationCodeRepository authorizationCodeRepository,
IBadgeRepository badgeRepository,
IBookRepository bookRepository,
IBranchRepository branchRepository,
IMailRepository mailRepository,
INotificationRepository notificationRepository,
IPrizeWinnerRepository prizeWinnerRepository,
IProgramRepository programRepository,
IRequiredQuestionnaireRepository requireQuestionnaireRepository,
IRoleRepository roleRepository,
ISchoolRepository schoolRepository,
ISiteRepository siteRepository,
IStaticAvatarRepository staticAvatarRepository,
ISystemRepository systemRepository,
IUserLogRepository userLogRepository,
IUserRepository userRepository,
IVendorCodeRepository vendorCodeRepository,
ActivityService activityService,
SampleDataService configurationService,
SchoolService schoolService)
: base(logger, userContextProvider)
{
_passwordValidator = Require.IsNotNull(passwordValidator, nameof(passwordValidator));
_authorizationCodeRepository = Require.IsNotNull(authorizationCodeRepository,
nameof(authorizationCodeRepository));
_badgeRepository = Require.IsNotNull(badgeRepository, nameof(badgeRepository));
_bookRepository = Require.IsNotNull(bookRepository, nameof(bookRepository));
_branchRepository = Require.IsNotNull(branchRepository, nameof(branchRepository));
_mailRepository = Require.IsNotNull(mailRepository, nameof(mailRepository));
_notificationRepository = Require.IsNotNull(notificationRepository,
nameof(notificationRepository));
_prizeWinnerRepository = Require.IsNotNull(prizeWinnerRepository,
nameof(prizeWinnerRepository));
_programRepository = Require.IsNotNull(programRepository, nameof(programRepository));
_requireQuestionnaireRepository = Require.IsNotNull(requireQuestionnaireRepository,
nameof(requireQuestionnaireRepository));
_roleRepository = Require.IsNotNull(roleRepository, nameof(roleRepository));
_schoolRepository = Require.IsNotNull(schoolRepository, nameof(schoolRepository));
_siteRepository = Require.IsNotNull(siteRepository, nameof(siteRepository));
_staticAvatarRepository = Require.IsNotNull(staticAvatarRepository,
nameof(staticAvatarRepository));
_systemRepository = Require.IsNotNull(systemRepository, nameof(systemRepository));
_userLogRepository = Require.IsNotNull(userLogRepository, nameof(userLogRepository));
_userRepository = Require.IsNotNull(userRepository, nameof(userRepository));
_vendorCodeRepository = Require.IsNotNull(vendorCodeRepository, nameof(vendorCodeRepository));
_activityService = Require.IsNotNull(activityService, nameof(activityService));
_configurationService = Require.IsNotNull(configurationService,
nameof(configurationService));
_schoolService = Require.IsNotNull(schoolService, nameof(schoolService));
}
public BadgeReport(ILogger <CurrentStatusReport> logger,
ServiceFacade.Report serviceFacade,
IBadgeRepository badgeRepository,
IChallengeRepository challengeRepository,
IUserLogRepository userLogRepository) : base(logger, serviceFacade)
{
_badgeRepository = badgeRepository
?? throw new ArgumentNullException(nameof(badgeRepository));
_challengeRepository = challengeRepository
?? throw new ArgumentNullException(nameof(challengeRepository));
_userLogRepository = userLogRepository
?? throw new ArgumentNullException(nameof(userLogRepository));
}
public void MarkAsSolutionAwardTwoBadges()
{
_badgeRepository = Substitute.For<IBadgeRepository>();
_api.Topic = Substitute.For<ITopicAPI>();
_badgeService = new BadgeService(_badgeRepository, _api, _loggingService, _localizationService, _activityService);
// Create a user with one topic marked as solved
var id = Guid.NewGuid();
var user = new MembershipUser
{
Id = id,
Badges = new List<Badge>(),
BadgeTypesTimeLastChecked = new List<BadgeTypeTimeLastChecked>
{ new BadgeTypeTimeLastChecked
{ BadgeType = BadgeType.VoteUp.ToString() , TimeLastChecked = GetTimeAllowsBadgeUpdate()} }
};
var listPostsForMember = new List<Post> {
new Post
{
User = new MembershipUser
{
Id = user.Id,
Badges = new List<Badge>()
},
},
};
var listTopicsForMember = new List<Topic>
{
new Topic
{
Solved = true,
User = new MembershipUser
{
Id = user.Id,
Badges = new List<Badge>()
},
},
};
_api.Topic.GetSolvedTopicsByMember(id).Returns(listTopicsForMember);
_api.Post.GetSolutionsWrittenByMember(id).Returns(listPostsForMember);
_badgeRepository.Get(Arg.Any<Guid>()).Returns(new Badge { Name = "testbadge" });
_badgeService.ProcessBadge(BadgeType.MarkAsSolution, user);
Assert.IsTrue(user.Badges.Count == 2);
}
public void AnniversaryTimeAwardBadge()
{
_badgeRepository = Substitute.For<IBadgeRepository>();
_api.Topic = Substitute.For<ITopicAPI>();
_badgeService = new BadgeService(_badgeRepository, _api, _loggingService, _localizationService, _activityService);
var now = DateTime.UtcNow;
var user = new MembershipUser
{
CreateDate = new DateTime(now.Year - 1, now.Month, now.Day),
Badges = new List<Badge>(),
BadgeTypesTimeLastChecked = new List<BadgeTypeTimeLastChecked>
{ new BadgeTypeTimeLastChecked
{ BadgeType = BadgeType.VoteUp.ToString() , TimeLastChecked = GetTimeAllowsBadgeUpdate()} }
};
_badgeRepository.Get(Arg.Any<Guid>()).Returns(new Badge { Name = "MemberForAYear" });
_badgeService.ProcessBadge(BadgeType.Time, user);
Assert.IsTrue(user.Badges.Count == 1);
Assert.IsTrue(user.Badges[0].Name == "MemberForAYear");
}
public void VoteUpAwardOneBadgeOutOfTwo()
{
_badgeRepository = Substitute.For<IBadgeRepository>();
_badgeService = new BadgeService(_badgeRepository, _api, _loggingService, _localizationService, _activityService);
// Create a user with one post with one vote, and no badge, and one post with no votes
var user = new MembershipUser
{
Posts = new List<Post> {
new Post{
Id = Guid.NewGuid(),
Votes = new List<Vote> { new Vote { Id = Guid.NewGuid() } },
}
},
Badges = new List<Badge>(),
Votes = new List<Vote>(),
BadgeTypesTimeLastChecked = new List<BadgeTypeTimeLastChecked>
{ new BadgeTypeTimeLastChecked
{ BadgeType = BadgeType.VoteUp.ToString() , TimeLastChecked = GetTimeAllowsBadgeUpdate()} }
};
_badgeRepository.Get(Arg.Any<Guid>()).Returns(new Badge { Name = "testbadge" });
_badgeService.ProcessBadge(BadgeType.VoteUp, user);
Assert.IsTrue(user.Badges.Count == 2);
}
public void TopicAuthorMarkAsSolutionAwardBadge2()
{
_badgeRepository = Substitute.For<IBadgeRepository>();
_api.Topic = Substitute.For<ITopicAPI>();
_badgeService = new BadgeService(_badgeRepository, _api, _loggingService, _localizationService, _activityService);
// Create a user with two topics marked as solved BUT no badge yet so will be awarded
var id = Guid.NewGuid();
var user = new MembershipUser
{
Id = id,
Badges = new List<Badge>(),
BadgeTypesTimeLastChecked = new List<BadgeTypeTimeLastChecked>
{ new BadgeTypeTimeLastChecked
{ BadgeType = BadgeType.VoteUp.ToString() , TimeLastChecked = GetTimeAllowsBadgeUpdate()} }
};
var listTopicsForMember = new List<Topic>
{
new Topic
{
Solved = true,
User = new MembershipUser
{
Id = user.Id,
Badges = new List<Badge>()
},
},
new Topic
{
Solved = true,
User = new MembershipUser
{
Id = user.Id,
Badges = new List<Badge>()
},
},
};
_api.Topic.GetSolvedTopicsByMember(id).Returns(listTopicsForMember);
_badgeService.ProcessBadge(BadgeType.MarkAsSolution, user);
Assert.IsTrue(user.Badges.Count == 1);
}
public UserController()
{
_movieRepository = new MovieRepository();
_badgeRepository = new BadgeRepository();
_seenRepository = new SeenRepository();
}
public void VoteUpAwardTwoBadges()
{
_badgeRepository = Substitute.For<IBadgeRepository>();
_badgeService = new BadgeService(_badgeRepository, _api, _loggingService, _localizationService, _activityService);
// Create a user with one post with one vote, and no badge, and one post with one vote
var post = new Post
{
Id = Guid.NewGuid(),
Votes = new List<Vote> { new Vote { Id = Guid.NewGuid() } },
};
var user = new MembershipUser
{
Posts = new List<Post> { post },
Badges = new List<Badge>(),
Votes = new List<Vote>
{
new Vote { Id = Guid.NewGuid() }
},
BadgeTypesTimeLastChecked = new List<BadgeTypeTimeLastChecked>
{ new BadgeTypeTimeLastChecked
{ BadgeType = BadgeType.VoteUp.ToString() , TimeLastChecked = GetTimeAllowsBadgeUpdate()} }
};
_badgeRepository.Get(Arg.Any<Guid>()).Returns(new Badge { Name = "testbadge" });
_badgeService.ProcessBadge(BadgeType.VoteUp, user);
Assert.IsTrue(user.Badges.Count == 3);
// These tests can no longer work as we now fetch back the db badge records using a substitute
//var foundPosterVoteUp = false;
//var foundUserVoteUp = false;
//foreach (var badge in user.Badges)
//{
// if (badge.Name == "PosterVoteUp" || badge.Name == NameTestVoteUp)
// {
// foundPosterVoteUp = true;
// }
// else if (badge.Name == "UserVoteUp")
// {
// foundUserVoteUp = true;
// }
//}
//Assert.IsTrue(foundPosterVoteUp);
//Assert.IsTrue(foundUserVoteUp);
}
public void Init()
{
_loggingService = Substitute.For<ILoggingService>();
_badgeRepository = Substitute.For<IBadgeRepository>();
_membershipRepository = Substitute.For<IMembershipRepository>();
}
public BadgeLogic(IUnitOfWork unit, IBadgeRepository repo)
{
this.Unit = unit;
this.Repo = repo;
}
public void SyncBadgesDeleteOldBadgeRecords()
{
_badgeRepository = Substitute.For<IBadgeRepository>();
_badgeService = new BadgeService(_badgeRepository, _api, _loggingService, _localizationService, _activityService);
var badgesInDbAlready = new List<Badge>
{
new Badge
{
Id = new Guid("2ac1fc11-2f9e-4d5a-9df4-29715f10b6d1"),
Name = "PosterVoteUp"
},
new Badge
{
Id = new Guid("2ac1fc11-2f9e-4d5a-9df4-29715f10b6d2"),
Name = "BadgeWithNoMatchingClass"
}
};
_badgeRepository.GetAll().Returns(badgesInDbAlready);
_badgeService.SyncBadges();
_badgeRepository.Received().Delete(Arg.Is<Badge>(x => x.Name == "BadgeWithNoMatchingClass"));
}
public void SyncBadgesUpdateBadgeRecords()
{
_badgeRepository = Substitute.For<IBadgeRepository>();
_badgeService = new BadgeService(_badgeRepository, _api, _loggingService, _localizationService, _activityService);
var badgeInDb = new Badge
{
Id = new Guid(GuidTestVoteUp),
Name = "XXX",
DisplayName = "XXX",
Description = "XXX",
Image = "XXX"
};
var badgesInDbAlready = new List<Badge>
{
badgeInDb
};
_badgeRepository.GetAll().Returns(badgesInDbAlready);
_badgeService.SyncBadges();
// The test badge class has been identified as the same badge as found in the "database", so that database
// badge's fields have been updated with the test badge class's attributes
Assert.IsTrue(badgeInDb.Name == NameTestVoteUp);
Assert.IsTrue(badgeInDb.Description == DescriptionTestVoteUp);
Assert.IsTrue(badgeInDb.DisplayName == DisplayNameTestVoteUp);
Assert.IsTrue(badgeInDb.Image == ImageTestVoteUp);
}
public void SyncBadgesCreateNewBadgeRecords()
{
_badgeRepository = Substitute.For<IBadgeRepository>();
_badgeService = new BadgeService(_badgeRepository, _api, _loggingService, _localizationService, _activityService);
_badgeService.SyncBadges();
_badgeRepository.Received().Add(Arg.Is<Badge>(x => x.Name == "PosterVoteUp"
&& x.Id.ToString() == "2ac1fc11-2f9e-4d5a-9df4-29715f10b6d1"
&& x.Image == "PosterVoteUpBadge.png"
&& x.Description == "This badge is awarded to users after they receive their first vote up from another user."));
}
public void Init()
{
_api = Substitute.For<IMVCForumAPI>();
_loggingService = Substitute.For<ILoggingService>();
_localizationService = Substitute.For<ILocalizationService>();
_activityService = Substitute.For<IActivityService>();
AppendBadgeClassPath();
// Ensure a database sync
_badgeRepository = Substitute.For<IBadgeRepository>();
_badgeService = new BadgeService(_badgeRepository, _api, _loggingService, _localizationService, _activityService);
_badgeService.SyncBadges();
}
public UserController(IMovieRepository movieRepository, ISeenRepository seenRepository, IBadgeRepository badgeRepository)
{
_movieRepository = movieRepository;
_seenRepository = seenRepository;
_badgeRepository = badgeRepository;
}
public void AnniversaryTimeBadgeRefuseBadge()
{
_badgeRepository = Substitute.For<IBadgeRepository>();
_api.Topic = Substitute.For<ITopicAPI>();
_badgeService = new BadgeService(_badgeRepository, _api, _loggingService, _localizationService, _activityService);
var now = DateTime.UtcNow;
var user = new MembershipUser
{
CreateDate = new DateTime(now.Year, now.Month, now.Day),
Badges = new List<Badge>(),
BadgeTypesTimeLastChecked = new List<BadgeTypeTimeLastChecked>
{ new BadgeTypeTimeLastChecked
{ BadgeType = BadgeType.VoteUp.ToString() , TimeLastChecked = GetTimeAllowsBadgeUpdate()} }
};
_badgeService.ProcessBadge(BadgeType.MarkAsSolution, user);
Assert.IsTrue(user.Badges.Count == 0);
}
public void UserVoteUpAwardBadge2()
{
_badgeRepository = Substitute.For<IBadgeRepository>();
_badgeService = new BadgeService(_badgeRepository, _api, _loggingService, _localizationService, _activityService);
// Create a user with two votes no badges - will create a badge because no previous badge
var user = new MembershipUser
{
Votes = new List<Vote>
{
new Vote { Id = Guid.NewGuid() },
new Vote { Id = Guid.NewGuid() }
},
Badges = new List<Badge>(),
BadgeTypesTimeLastChecked = new List<BadgeTypeTimeLastChecked>
{ new BadgeTypeTimeLastChecked
{ BadgeType = BadgeType.VoteUp.ToString() , TimeLastChecked = GetTimeAllowsBadgeUpdate()} }
};
_badgeRepository.Get(Arg.Any<Guid>()).Returns(new Badge { Name = "UserVoteUp" });
_badgeService.ProcessBadge(BadgeType.VoteUp, user);
Assert.IsTrue(user.Badges.Count == 1);
Assert.IsTrue(user.Badges[0].Name == "UserVoteUp");
}
public void UserAlreadyHasBadge()
{
_badgeRepository = Substitute.For<IBadgeRepository>();
_badgeService = new BadgeService(_badgeRepository, _api, _loggingService, _localizationService, _activityService);
// Create a user with one vote no badges
var user = new MembershipUser
{
Votes = new List<Vote>
{
new Vote { Id = Guid.NewGuid() }
},
Badges = new List<Badge>(),
BadgeTypesTimeLastChecked = new List<BadgeTypeTimeLastChecked>
{ new BadgeTypeTimeLastChecked
{ BadgeType = BadgeType.VoteUp.ToString() , TimeLastChecked = GetTimeAllowsBadgeUpdate()} }
};
// Call twice but only one badge awarded
_badgeRepository.Get(Arg.Any<Guid>()).Returns(new Badge { Name = "testbadge" });
_badgeService.ProcessBadge(BadgeType.VoteUp, user);
_badgeService.ProcessBadge(BadgeType.VoteUp, user);
Assert.IsTrue(user.Badges.Count == 1);
}
public void PosterVoteUpRefuseBadge_TooSoon()
{
_badgeRepository = Substitute.For<IBadgeRepository>();
_badgeService = new BadgeService(_badgeRepository, _api, _loggingService, _localizationService, _activityService);
// Create a user with one post with one vote
var post = new Post
{
Id = Guid.NewGuid(),
Votes = new List<Vote> { new Vote { Id = Guid.NewGuid() } },
};
var user = new MembershipUser
{
Posts = new List<Post> { post },
Badges = new List<Badge>(),
BadgeTypesTimeLastChecked = new List<BadgeTypeTimeLastChecked>
{ new BadgeTypeTimeLastChecked
{ BadgeType = BadgeType.VoteUp.ToString() , TimeLastChecked = GetTimeDisAllowsBadgeUpdate()} }
};
_badgeService.ProcessBadge(BadgeType.VoteUp, user);
Assert.IsTrue(user.Badges.Count == 0);
}
public void UserVoteUpAwardBadgeTwoUsers()
{
// Useful for testing badge service internal badge class instance cache is called
_badgeRepository = Substitute.For<IBadgeRepository>();
_badgeService = new BadgeService(_badgeRepository, _api, _loggingService, _localizationService, _activityService);
// Create a user with one vote no badges, set time checking offset to be safe so badge will be processed
var user1 = new MembershipUser
{
Votes = new List<Vote>
{
new Vote { Id = Guid.NewGuid() }
},
Badges = new List<Badge>(),
BadgeTypesTimeLastChecked = new List<BadgeTypeTimeLastChecked>
{ new BadgeTypeTimeLastChecked
{ BadgeType = BadgeType.VoteUp.ToString() , TimeLastChecked = GetTimeAllowsBadgeUpdate()} }
};
// Create a user with one vote no badges, set time checking offset to be safe so badge will be processed
var user2 = new MembershipUser
{
Votes = new List<Vote>
{
new Vote { Id = Guid.NewGuid() }
},
Badges = new List<Badge>(),
BadgeTypesTimeLastChecked = new List<BadgeTypeTimeLastChecked>
{ new BadgeTypeTimeLastChecked
{ BadgeType = BadgeType.VoteUp.ToString() , TimeLastChecked = GetTimeAllowsBadgeUpdate()} }
};
_badgeRepository.Get(Arg.Any<Guid>()).Returns(new Badge { Name = "UserVoteUp" });
_badgeService.ProcessBadge(BadgeType.VoteUp, user1);
_badgeService.ProcessBadge(BadgeType.VoteUp, user2);
Assert.IsTrue(user1.Badges.Count == 1);
Assert.IsTrue(user1.Badges[0].Name == "UserVoteUp");
Assert.IsTrue(user2.Badges.Count == 1);
Assert.IsTrue(user2.Badges[0].Name == "UserVoteUp");
}
public BadgeService(IBadgeRepository aBadgeRepo)
{
theBadgeRepository = aBadgeRepo;
}