public SessionTopicsController(ISessionRepository sessionRepository, ITeamsService teamsService,
IHubContext <SessionsHub, ISessionsHub> sessionsHub)
{
_sessionRepository = sessionRepository;
_teamsService = teamsService;
_sessionsHub = sessionsHub;
}
public SessionService(
[FromServices] ISessionRepository sessionRepository,
[FromServices] IMapper mapper)
{
this.sessionRepository = sessionRepository;
this.mapper = mapper;
}
public void Setup()
{
mockMembershipRepository = Substitute.For <IMembershipRepository>();
mockSessionRepository = Substitute.For <ISessionRepository>();
membershipService = new MembershipService(mockMembershipRepository, mockSessionRepository);
}
public PinpadModel(IOptions <AppSettings> appSettings, ISessionRepository sessionRepository, IHttpClientRepository clients)
{
this.appSettings = appSettings.Value;
this.sessionRepository = sessionRepository;
this.clients = clients;
token = string.Empty;
}
public TeamService(ITeamRepository teamRepo, ISpelerRepository spelerRepo, ISessionRepository sessieRepo, IPuzzelRepository puzzelRepo)
{
_teamRepo = teamRepo;
_sessieRepo = sessieRepo;
_spelerRepo = spelerRepo;
_puzzelRepo = puzzelRepo;
}
public AuthorizationService(IAccountRepository accountRepository, ISessionRepository sessionRepository, IPasswordHashManager passwordHashManager)
{
_accountRepository = accountRepository;
_sessionRepository = sessionRepository;
_passwordHashManager = passwordHashManager;
}
public TeamService(GameContext context)
{
_teamRepo = new TeamRepository(context);
_sessieRepo = new SessieRepository(context);
_spelerRepo = new SpelerRepository(context);
_puzzelRepo = new PuzzelRepository(context);
}
/// <summary>
/// Session controller constructor.
/// </summary>
/// <param name="sessionRepository">The session repository.</param>
/// <param name="materialRepository">The material repository.</param>
/// <param name="eventsRepository">The events repository.</param>
/// <param name="authorizationService">The authorization service.</param>
public SessionController(ISessionRepository sessionRepository, IMaterialRepository materialRepository, IEventDefinitionRepository eventsRepository, IAuthorizationService authorizationService)
{
_sessionRepository = sessionRepository;
_materialRepository = materialRepository;
_eventsRepository = eventsRepository;
_authorizationService = authorizationService;
}
public void Init()
{
var container = new StandardKernel();
container.Bind<ISessionRepository>().ToConstant(MoqSessionRepositoryFactory.GetSessionRepositoryMock());
_sessionRepository = container.Get<ISessionRepository>();
_sessionRepository.Clear();
}
public SessionController()
{
const string connectionString = @"server=192.168.11.70\SQLEXPRESS,1433;database=abraham;uid=sa;password=toto;Application Name=Homer";
_repository = new SessionRepository(connectionString);
_service = new SessionService(_repository);
}
public SessionService(ISessionRepository sessionRepository, ISessionReservationRepository sessionReservationRepository, ITutorRepository tutorRepository, IUnitOfWork unitOfWork)
{
_sessionRepository = sessionRepository;
_sessionReservationRepository = sessionReservationRepository;
_tutorRepository = tutorRepository;
_unitOfWork = unitOfWork;
}
public WorldController(INationRepository nationRepository, IRegionRepository regionRepository, ISessionRepository sessionRepository, IWorldRepository worldRepository)
{
NationRepository = nationRepository;
RegionRepository = regionRepository;
SessionRepository = sessionRepository;
WorldRepository = worldRepository;
}
private void InstantiateRepositories(ApplicationUser user,
out ISessionRepository sessionRepository,
out IPhotoRepository photoRepository,
out IRecognitionResultsRepository recognitionResultsRepository)
{
var repository = new MockRepository(MockBehavior.Default);
image = new byte[] { 0x20, 0x20, 0x20 };
testResults = new RecognitionResults(true, new Points(new Point(0, 1), new Point(2, 3)), photoId);
var timeStamp = new DateTime();
var userId = user.Id;
Session testSession = new Session(user.Id, timeStamp, timeStamp, SessionStatus.ACTIVE);
testSession.SessionID = 1;
Photo testPhoto = new Photo(testSession.SessionID, image, timeStamp);
testPhoto.PhotoID = 2;
sessionRepository = repository.Of <ISessionRepository>()
.Where(sr => sr.GetLastSessionForUser(It.IsAny <int>()) == testSession)
.First();
photoRepository = repository.Of <IPhotoRepository>()
.Where(pr => pr.GetLastPhotoInSession(It.IsAny <int>()) == testPhoto)
.First();
recognitionResultsRepository = repository.Of <IRecognitionResultsRepository>()
.Where(rr => rr.GetRecognitionResultsByPhotoId(It.IsAny <int>()) == testResults)
.First();
}
public InitSessionRequestHandler(
ISessionRepository sessionRepository,
IDateTimeOffsetService dateTimeOffsetService)
{
this.sessionRepository = sessionRepository ?? throw new ArgumentNullException(nameof(sessionRepository));
this.dateTimeOffsetService = dateTimeOffsetService ?? throw new ArgumentNullException(nameof(dateTimeOffsetService));
}
public AuthController(IUsersRepository usersRepository, IMapper mapper, ISessionRepository sessionRepository, SessionDto sessionDto)
{
_usersRepository = usersRepository;
_mapper = mapper;
_sessionRepository = sessionRepository;
_sessionDto = sessionDto;
}
public AccountManager(
ISecurityProvider securityProvider,
IAccountRepository accountRepository,
IAccountValidator accountValidator,
ITimeSource timeSource,
int accountSessionCollectionCapacity,
ISessionRepository sessionRepository,
IActionRightResolver actionRightResolver/*,
Func<TBizAccountRegistrationData, TBizAccount> accountRegistrationDataToAccount*/)
{
// todo1[ak] check args
_securityProvider = securityProvider;
_accountRepository = accountRepository;
_accountValidator = accountValidator;
_timeSource = timeSource;
_sessionManager = new SessionManager(
_securityProvider,
_timeSource,
accountSessionCollectionCapacity,
sessionRepository);
_actionRightResolver = actionRightResolver;
//_accountRegistrationDataToAccount = accountRegistrationDataToAccount;
}
/// <summary>
/// Initializes a new instance of the <see cref="CodeCampService"/> class.
/// </summary>
/// <param name="repository">The repository.</param>
/// <param name="codeCampRepository"></param>
/// <param name="speakerRepository"></param>
/// <param name="mapper">The mapper.</param>
public SessionService(ISessionRepository repository, ICodeCampRepository codeCampRepository, ISpeakerRepository speakerRepository, IMapper mapper)
{
_repository = repository;
_codeCampRepository = codeCampRepository;
_speakerRepository = speakerRepository;
_mapper = mapper;
}
public async Task ShouldGetMessageResult()
{
Guid sessionId = Guid.NewGuid();
ISessionRepository repository = Substitute.For <ISessionRepository>();
MessageBuilder leftMessageBuilder = new MessageBuilder().WithData(ApplicationConstants.DefaultData);
MessageBuilder rightMessageBuilder = new MessageBuilder().WithData(ApplicationConstants.SameSizeDifferentData);
repository.Get(sessionId.ToString())
.Returns(new SessionBuilder(sessionId.ToString())
.WithLeftSideMessage(leftMessageBuilder)
.WithRightSideMessage(rightMessageBuilder)
.Build());
DiffController controller = new DiffController(repository);
ActionResult result = await controller.Get(sessionId);
result.ShouldBeAssignableTo <OkObjectResult>();
((OkObjectResult)result).Value.ToString().ShouldContain("Differences found starting at 3 ending at 5");
((OkObjectResult)result).Value.ToString().ShouldContain("Differences found starting at 66 ending at 68");
}
public SessieServiceTest()
{
_fakeTeamRepo = new TeamRepositoryFake();
_fakeSessieRepo = new SessieRepoFake();
_fakePuzzelRepo = new PuzzelRepoFake();
_service = new SessieService(_fakeSessieRepo, _fakeTeamRepo, _fakePuzzelRepo);
}
public DataProviderService(ISessionRepository sessionRepository, IUserRepository userRepository, IItemRepository itemRepository)
{
this.context = new HardwareInventoryEntities();
this._sessionRepository = sessionRepository;
this._userRepository = userRepository;
this._itemRepository = itemRepository;
}
public AppStoresWapUIController(IAppStoresWapUISerivces appStoresWapUISerivces, ISessionRepository sessionRepository, ICookieService cookieService, IAppStoreService appStoreService)
{
AppStoresWapUISerivces = appStoresWapUISerivces;
SessionRepository = sessionRepository;
CookieService = cookieService;
_appStoreService = appStoreService;
}
public RpcUserSessionRepository(IRepositoryFactory repositoryFactory, Persistence.Models.User user)
{
_repositoryFactory = repositoryFactory;
_user = user;
_sessionRepository = _repositoryFactory.GetSessionRepository();
}
public SessionService(
ISessionRepository sessionRepository,
ILogWrapper logger)
{
SessionRepository = sessionRepository;
Logger = logger;
}
public SessionsController(ISessionRepository sessionRepository, IAthleteRepository athleteRepository,
IErrorRepository _errorsRepository, IUnitOfWork _unitOfWork)
: base(_errorsRepository, _unitOfWork)
{
_sessionRepository = sessionRepository;
_athleteRepository = athleteRepository;
}
public SellSessionSeatCommandHandler(
IUnitOfWork unitOfWork,
ISessionRepository sessionRepository)
{
_unitOfWork = unitOfWork;
_sessionRepository = sessionRepository;
}
public void OpeningMultipleSessionsShouldKeepOnlyOneActiveSession(int numberOfSessions)
{
IHubContext <SessionHub> hubContext = null;
ISessionRepository sessionRepository = null;
IReadOnlyRepository <string, HubConnectionContext> connectionRepository = null;
Thread[] threads = null;
SessionHubMethods <SessionHub> hubMethods = null;
ConcurrentQueue <Exception> exceptions = null;
"Given Axle SignalR hub"
.x(() =>
{
exceptions = new ConcurrentQueue <Exception>();
threads = new Thread[numberOfSessions];
hubContext = A.Fake <IHubContext <SessionHub> >();
sessionRepository = new InMemorySessionRepository();
connectionRepository = A.Fake <IReadOnlyRepository <string, HubConnectionContext> >();
A.CallTo(() => connectionRepository.Get(A <string> .Ignored)).Returns(A.Fake <HubConnectionContext>());
hubMethods = new SessionHubMethods <SessionHub>(hubContext, sessionRepository, connectionRepository);
});
"When I open multiple sessions with the same user ID"
.x(() =>
{
for (int i = 0; i < numberOfSessions; i++)
{
threads[i] = new Thread(() => SafeExecute(() => this.StartSession(hubMethods), exceptions));
}
for (int i = 0; i < numberOfSessions; i++)
{
threads[i].Start();
}
});
"Then only one session of that user remains"
.x(() =>
{
Thread.Sleep(500);
exceptions.Should().BeEmpty();
var activeSessionsOfUser = sessionRepository.GetByUser(UserId);
activeSessionsOfUser.Count().Should().Be(1);
})
.Teardown(() =>
{
foreach (var thread in threads)
{
if (thread.IsAlive)
{
thread.Join();
}
}
});
}
public async Task <IActionResult> GetPhoto([FromServices] UserManager <ApplicationUser> userManager,
[FromServices] IPhotoRepository photoRepository,
[FromServices] ISessionRepository sessionRepository,
[FromServices] IRecognitionResultsRepository recognitionResultsRepository)
{
using (_logger.BeginScope(nameof(GetPhoto)))
{
_logger.LogInformation("Frontend tries to get photo");
try
{
var user = await userManager.GetUserAsync(HttpContext.User);
var session =
sessionRepository.GetLastSessionForUser(int.Parse(await userManager.GetUserIdAsync(user)));
if (null == session)
{
return(BadRequest("User has no sessions"));
}
var photo = photoRepository.GetLastPhotoInSession(session.SessionID);
var recognitionResults = recognitionResultsRepository.GetRecognitionResultsByPhotoId(photo.PhotoID);
var recognitionResultsResponse = (null == recognitionResults)
?
null
:
new
{
valid = recognitionResults.IsValid,
coordinates = new
{
topLeft = new
{
x = recognitionResults.Coords.TopLeft.X,
y = recognitionResults.Coords.TopLeft.Y
},
bottomRight = new
{
x = recognitionResults.Coords.BottomRight.X,
y = recognitionResults.Coords.BottomRight.Y
}
}
};
return(Ok(new
{
photo = System.Convert.ToBase64String(photo.Image),
recognitionResults = recognitionResultsResponse
}
));
}
catch (Exception exception)
{
_logger.LogError("Exception caught: {0}, {1}", exception.Message, exception.StackTrace);
return(BadRequest(exception.Message));
}
}
}
public SessionController(IConferenceLoader conferenceLoader, IUserProfileRepository userProfileRepository, ISessionRepository sessionRepository, ISessionSorter sorter, EmailMessengerFactory messengerFactory)
{
this.conferenceLoader = conferenceLoader;
this.userProfileRepository = userProfileRepository;
this.sessionRepository = sessionRepository;
sessionSorter = sorter;
emailMessengerFactory = messengerFactory;
}
public SessionController(ISessionRepository repository,
LinkGenerator linkGenerator,
IOptions <AppSettings> appSettings)
{
_sessionRepository = repository;
_linkGenerator = linkGenerator;
_appSettings = appSettings.Value;
}
public SessionService(ISessionRepository sessionRepository, IUnitOfWork unitOfWork, IHistoryRepository historyRepository, IEquipamentSessionRepository equipamentSessionRepository, ITagSessionRepository tagSessionRepository)
{
_sessionRepository = sessionRepository;
_unitOfWork = unitOfWork;
_historyRepository = historyRepository;
_equipamentSessionRepository = equipamentSessionRepository;
_tagSessionRepository = tagSessionRepository;
}
public SessionManager(ISessionRepository repository)
{
_repository = repository;
_sessionsCache = new Collection<Session>();
_removedSessionsCache = new Collection<Session>();
Load();
}
public CourseMaterialController(ISessionRepository sessionRepository, IUserRepository userRepository,
ICourseMaterialRepository courseMaterialRepository, ICommentRepository commentRepository)
{
_sessionRepository = sessionRepository;
_userRepository = userRepository;
_courseMaterialRepository = courseMaterialRepository;
_commentRepository = commentRepository;
}
public AuthController(IAuthRepository authRepo, IPhotoRepository photoRepo, ISessionRepository sessionRepo, IConfiguration config, IMapper mapper)
{
this.photoRepo = photoRepo;
this.mapper = mapper;
this.authRepo = authRepo;
this.sessionRepo = sessionRepo;
this.config = config;
}
public SessionApplicationService(IPersonApplicationService servicePerson, ISessionRepository repositorySession, ICoacheeRepository repositoryCoachee, ICoachRepository repositoryCoach, IUnitOfWork unitOfWork)
: base(unitOfWork)
{
this._repositorySession = repositorySession;
this._repositoryCoachee = repositoryCoachee;
this._repositoryCoach = repositoryCoach;
this._servicePerson = servicePerson;
}
public ModuleProcessor(IMapper mapper, IModuleRepository moduleRepository, IClassroomRepository classroomRepository, IValidator <Classroom> classroomValidator, ISessionRepository sessionRepository)
{
_mapper = mapper;
_moduleRepository = moduleRepository;
_classroomRepository = classroomRepository;
_classroomValidator = classroomValidator;
_sessionRepository = sessionRepository;
}
public SessionService(ISessionRepository sessionRepository, IAuthenticationService authenticationService)
{
if (sessionRepository == null) throw new ArgumentNullException("sessionRepository");
if (sessionRepository == null) throw new ArgumentNullException("sessionRepository");
SessionRepository = sessionRepository;
AuthenticationService = authenticationService;
}
public CreateNextSessionViewModel(ISessionLogViewModel sessionLogViewModel, IScheduleViewModel scheduleViewModel, ISessionRepository sessionRepository, IUserInterfaceState userInterfaceState)
{
_sessionLogViewModel = sessionLogViewModel;
_sessionRepository = sessionRepository;
_scheduleViewModel = scheduleViewModel;
_userInterfaceState = userInterfaceState;
CreateNextSession = new RelayCommand(CreateNextSessionExecute);
}
public SignInWithEmailUseCase(IUserRepository userRepository, SnakeCaseConverter snakeCaseConverter, ISessionRepository sessionRepository, ITokenRepository tokenRepository, AuthUtils authOptions)
{
this.userRepository = userRepository;
this.snakeCaseConverter = snakeCaseConverter;
this.sessionRepository = sessionRepository;
this.tokenRepository = tokenRepository;
this.authOptions = authOptions;
}
public SelectSeatTaskService(ISelectSeatTaskQueryService seatTaskQueryService,
ISelectSeatTaskRepository selectSeatTaskRepository, ISessionRepository sessionRepository, ITransactionRepository transactionRepository)
{
this._seatTaskQueryService = seatTaskQueryService;
this._selectSeatTaskRepository = selectSeatTaskRepository;
this._sessionRepository = sessionRepository;
this._transactionRepository = transactionRepository;
}
public Handler(ISessionRepository repository, IAppDbContext context, IOptionsSnapshot <AuthenticationSettings> authenticationSettings, IPasswordHasher passwordHasher, ITokenManager tokenManager)
{
_context = context;
_authenticationSettings = authenticationSettings;
_repository = repository;
_passwordHasher = passwordHasher;
_tokenManager = tokenManager;
}
public CurriculumServices(ICurriculumRepository curriculumRepository, ISessionRepository curriculumSessionRepository, IClubRepository clubRepository, ICurriculumStatementRepository curriculumStatementRepository, IStatementRolesRepository statementRolesRepository, IScenarioRepository scenarioRepository)
{
_curriculumRepository = curriculumRepository;
_sessionRepository = curriculumSessionRepository;
_clubRepository = clubRepository;
_curriculumStatementRepository = curriculumStatementRepository;
_statementRolesRepository = statementRolesRepository;
_scenarioRepository = scenarioRepository;
}
public MobileSMSValidate(int verifyCodeLen = 6)
{
verifyLen = verifyCodeLen;
_session = new SessionRepository();
if (verifyMode == null)
{
verifyMode = InitMobileVerifyMode();
}
}
public SessionController(IGenericRepository genericRepository,
IMapper<CreateModel, Session> createModelToEntityMapper,
IMapper<Session, IndexModel> entityToIndexModelMapper, ISessionRepository sessionRepository)
{
_genericRepository = genericRepository;
_createModelToEntityMapper = createModelToEntityMapper;
_entityToIndexModelMapper = entityToIndexModelMapper;
_sessionRepository = sessionRepository;
}
public UserProfileFilterFactory(ISessionRepository sessionRepository)
{
if (sessionRepository == null)
{
throw new ArgumentNullException("sessionRepository");
}
this.sessionRepository = sessionRepository;
}
public SubmittedSessionProfileFilter(ISessionRepository sessionRepository)
{
if (sessionRepository == null)
{
throw new ArgumentNullException("sessionRepository");
}
this.sessionRepository = sessionRepository;
}
public AppStoreUIServiceBase(IAppStoreUIService appStoreUIService, IRedisService redisService, IAppStoreService appStoreService, ISessionRepository sessionRepository, ICookieService cookieService, IFullTextSearchService fullTextSearchService)
: base(redisService)
{
AppStoreUIService = appStoreUIService;
AppStoreService = appStoreService;
SessionRepository = sessionRepository;
CookieService = cookieService;
FullTextSearchService = fullTextSearchService;
}
public SessionLoaderFactory(ISessionRepository sessionRepository)
{
if (sessionRepository == null)
{
throw new ArgumentNullException("sessionRepository");
}
this.sessionRepository = sessionRepository;
}
public ParentCourseGradeController(IParentCourseRepository parentCourseRepository, IGenericRepository genericRepository, ISessionRepository sesssionRepository, ParentCourseGradesModelToStudentsMapper parentCourseGradesModelToStudentsMapper, StudentsSesssionParentCourseToParentCourseGradesModelMapper studentsSesssionParentCourseToParentCourseGradesModelMapper, ParentCourseGradeToCsvMapper parentCourseToCsvMapper)
{
_parentCourseRepository = parentCourseRepository;
_genericRepository = genericRepository;
_sesssionRepository = sesssionRepository;
_parentCourseGradesModelToStudentsMapper = parentCourseGradesModelToStudentsMapper;
_studentsSesssionParentCourseToParentCourseGradesModelMapper = studentsSesssionParentCourseToParentCourseGradesModelMapper;
_parentCourseToCsvMapper = parentCourseToCsvMapper;
}
public ISessionRepository GetISessionRepository()
{
//if (_sessionRepository == null)
// _sessionRepository = new MemorySessionRepository();
if (_sessionRepository == null)
_sessionRepository = new XmlSessionRepository();
return _sessionRepository;
}
public PresenceController(
ISessionRepository sessionRepository,
IPartyRepository partyRepository,
IPartyMemberRepository partyMemberRepository,
IUserPresenceRepository userPresenceRepository)
{
_sessionRepository = sessionRepository;
_partyRepository = partyRepository;
_partyMemberRepository = partyMemberRepository;
_userPresenceRepository = userPresenceRepository;
}
/// <summary>
/// Event controller contructor.
/// </summary>
/// <param name="eventsRepository"></param>
/// <param name="registeredUserRepository"></param>
/// <param name="sessionRepository"></param>
/// <param name="materialRepository"></param>
public EventController(
IEventDefinitionRepository eventsRepository,
IRegisteredUserRepository registeredUserRepository,
ISessionRepository sessionRepository,
IMaterialRepository materialRepository)
{
_eventsRepository = eventsRepository;
_registeredUserRepository = registeredUserRepository;
_sessionRepository = sessionRepository;
_materialRepository = materialRepository;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="commentRepository">ICommentRepository dependency</param>
/// <param name="sessionRepository">ISessionRepository dependency</param>
public CommentsController(ICommentRepository commentRepository, ISessionRepository sessionRepository)
{
if (sessionRepository == null)
throw new ArgumentNullException("sessionRepository");
if (commentRepository == null)
throw new ArgumentNullException("commentRepository");
_commentRepository = commentRepository;
_sessionRepository = sessionRepository;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="materialRepository">IMaterialRepository dependency</param>
/// <param name="sessionRepository">ISessionRepository dependency</param>
public MaterialsController(IMaterialRepository materialRepository , ISessionRepository sessionRepository)
{
if (sessionRepository == null)
throw new ArgumentNullException("sessionRepository");
if (materialRepository == null)
throw new ArgumentNullException("materialRepository");
_materialRepository = materialRepository;
_sessionRepository = sessionRepository;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="sessionRepository">ISessionRepository dependency</param>
/// <param name="eventDefinitionRepository">IEventDefinitionRepository dependency</param>
public SessionsController(ISessionRepository sessionRepository, IEventDefinitionRepository eventDefinitionRepository)
{
if (sessionRepository == null)
throw new ArgumentNullException("sessionRepository");
if (eventDefinitionRepository == null)
throw new ArgumentNullException("eventDefinitionRepository");
_sessionRepository = sessionRepository;
_eventDefinitionRepository = eventDefinitionRepository;
}
public SplashViewModel(INavigationService navigationService, ISessionRepository sessionRepository, ISpeakerRepository speakerRepository,
IAppService applicationService, IChangeRepository changeRepository, IChangeService changeService)
: base(navigationService)
{
// assignments
SessionRepository = sessionRepository;
SpeakerRepository = speakerRepository;
ChangeRepository = changeRepository;
ApplicationService = applicationService;
ChangeService = changeService;
LoadStatus = "Preparing Application...";
}
public static IAppProvider CreateAppProvider(
IAccountRepository adminRepository,
ISessionRepository adminSessionRepository,
int adminAccountSessionCollectionCapacity,
IActionRightResolver adminActionRightResolver,
IAccountRepository userRepository,
ISessionRepository userSessionRepository,
int userAccountSessionCollectionCapacity,
IActionRightResolver userActionRightResolver)
{
// todo1[ak] check args
RegisterMappings();
IAppProvider appProvider = new AppProvider();
ITimeSource timeSource = CreateTimeSource();
if (adminAccountSessionCollectionCapacity == 0)
{
adminAccountSessionCollectionCapacity = Constants.DEFAULT_ADMIN_ACCOUNT_SESSION_COLLECTION_CAPACITY;
}
if (userAccountSessionCollectionCapacity == 0)
{
userAccountSessionCollectionCapacity = Constants.DEFAULT_USER_ACCOUNT_SESSION_COLLECTION_CAPACITY;
}
IAccountManager adminManager = CreateAdminManager(
timeSource,
adminRepository,
adminSessionRepository,
adminAccountSessionCollectionCapacity,
adminActionRightResolver);
IAccountManager userManager = CreateUserManager(
timeSource,
userRepository,
userSessionRepository,
userAccountSessionCollectionCapacity,
userActionRightResolver);
appProvider.RegisterService<IGuestService>(new GuestService(adminManager, userManager));
appProvider.RegisterService<IAdminService>(new AdminService(adminManager, userManager));
appProvider.RegisterService<IUserService>(new UserService(userManager));
return appProvider;
}
public SpeakerRepository(ISessionRepository sessionRepository, IUserProfileRepository userProfileRepository)
{
if (sessionRepository == null)
{
throw new ArgumentNullException("sessionRepository");
}
if (userProfileRepository == null)
{
throw new ArgumentNullException("userProfileRepository");
}
this.sessionRepository = sessionRepository;
this.userProfileRepository = userProfileRepository;
}
public SessionController(ISessionRepository sessionRepository, IVoteRepository voteRepository)
{
if (sessionRepository == null)
{
throw new ArgumentNullException("sessionRepository");
}
if (voteRepository == null)
{
throw new ArgumentNullException("voteRepository");
}
this.sessionRepository = sessionRepository;
this.voteRepository = voteRepository;
}
internal SessionManager(ISecurityProvider securityProvider, ITimeSource timeSource, int accountSessionCollectionCapacity, ISessionRepository sessionRepository)
{
// todo1[ak] check args
_securityProvider = securityProvider;
_timeSource = timeSource;
_accountSessionCollectionCapacity = accountSessionCollectionCapacity;
_accountSessions = new Dictionary<string, IAccountSessionCollection>();
_lock = new object();
_allSessions = new Dictionary<string, BizSession>();
_sessionRepository = sessionRepository;
}
public UserController(IUserProfileRepository userProfileRepository, ILoginMethodLoader loginMethodLoader, ISessionRepository sessionRepository)
{
if (userProfileRepository == null)
{
throw new ArgumentNullException("userProfileRepository");
}
if (loginMethodLoader == null)
{
throw new ArgumentNullException("loginMethodLoader");
}
if (sessionRepository == null)
{
throw new ArgumentNullException("sessionRepository");
}
this.userProfileRepository = userProfileRepository;
this.loginMethodLoader = loginMethodLoader;
this.sessionRepository = sessionRepository;
}
