Пример #1
0
 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));
 }
Пример #2
0
 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));
 }
Пример #4
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");
        }
Пример #5
0
 /// <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;
 }
Пример #6
0
        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);
        }
Пример #7
0
 /// <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;
 }
Пример #8
0
        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);
        }
Пример #9
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");
        }
Пример #10
0
        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);
        }
Пример #11
0
 public BadgesController(IBadgeRepository repository,
                         ILogger <BadgesController> logger, IMapper mapper)
 {
     this.repository = repository;
     this.logger     = logger;
     this.mapper     = mapper;
 }
Пример #12
0
        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"));
        }
Пример #13
0
 public BadgeLogic(IBadgeRepository badgeRepository,
                   IMapper mapper,
                   IHttpContextAccessor contextAccessor)
 {
     _badgeRepository = badgeRepository;
     _mapper          = mapper;
     _contextAccessor = contextAccessor;
 }
Пример #14
0
 /// <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;
 }
Пример #16
0
 private static bool isDominating(Guid user_id, IBadgeRepository badgeRepo, int CurrentStreak)
 {
     if (isDuplicate(user_id, "Dominating", badgeRepo) != true && CurrentStreak == 4)
     {
         return(true);
     }
     return(false);
 }
Пример #17
0
 public BadgeServices(IBadgeRepository BadgeRepository)
 {
     if (BadgeRepository == null)
     {
         throw new ArgumentNullException("BadgeRepository");
     }
     this.badgeRepository = BadgeRepository;
 }
Пример #18
0
        public HomeController(IBadgeRepository ibadgeRepository, IPostRepository ipostRepository
				, ITagRepository itagRepository, IUserRepository iuserRepository)
        {
            this.ibadgeRepository = ibadgeRepository;
            this.ipostRepository = ipostRepository;
            this.itagRepository = itagRepository;
            this.iuserRepository = iuserRepository;
        }
Пример #19
0
 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));
 }
Пример #20
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 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;
 }
Пример #22
0
 /// <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;
 }
Пример #23
0
 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;
 }
Пример #24
0
 /// <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;
 }
Пример #26
0
 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."));
 }
Пример #27
0
 /// <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;
 }
Пример #28
0
        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);
        }
Пример #29
0
 public VehicleController(IVehicleRepository vehicleRepository,
                          IUnitOfWork unitOfWork,
                          IMakeRepository makeRepository,
                          IModelRepository modelRepository,
                          IBadgeRepository badgeRepository) : base(unitOfWork)
 {
     _vehicleRepository = vehicleRepository;
     _makeRepository    = makeRepository;
     _modelRepository   = modelRepository;
     _badgeRepository   = badgeRepository;
 }
Пример #30
0
 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));
 }
Пример #32
0
 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));
 }
Пример #33
0
 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));
 }
Пример #34
0
        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);
        }        
Пример #35
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");
        }
Пример #36
0
        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);
        }
Пример #37
0
        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);
        }
Пример #38
0
 public UserController()
 {
     _movieRepository = new MovieRepository();
     _badgeRepository = new BadgeRepository();
     _seenRepository = new SeenRepository();
 }
Пример #39
0
        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);
        }
Пример #40
0
 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;
 }
Пример #42
0
        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"));
        }
Пример #43
0
        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);
        }
Пример #44
0
 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."));
 }
Пример #45
0
        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();
        }
Пример #46
0
 public UserController(IMovieRepository movieRepository, ISeenRepository seenRepository, IBadgeRepository badgeRepository)
 {
     _movieRepository = movieRepository;
     _seenRepository = seenRepository;
     _badgeRepository = badgeRepository;
 }
Пример #47
0
        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);
        }
Пример #48
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");

        }
Пример #49
0
        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);
        }
Пример #50
0
        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);
        }
Пример #51
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");
        }
Пример #52
0
 public BadgeService(IBadgeRepository aBadgeRepo)
 {
     theBadgeRepository = aBadgeRepo;
 }