public OrderRepository(ApplicationContext context, IHttpContextAccessor contextAccessor,
IOrderItemRepository orderItemRepository, IRegisterRepository registerRepository) : base(context)
{
this.ContextAccessor = contextAccessor;
this.OrderItemRepository = orderItemRepository;
this.RegisterRepository = registerRepository;
}
public ConsumptionService(IRepository <Consumption> repository, IRegisterRepository <RemainNomenclature> remainNomenclature, IRegisterRepository <RemainCostPrice> remainCostPrice, IDb db)
{
_repository = repository;
_remainNomenclature = remainNomenclature;
_remainCostPrice = remainCostPrice;
_table = db.GetTable <RemainNomenclatureBalance>();
}
public UpdateEpaOrganisationContactHandler(IRegisterRepository registerRepository, IEpaOrganisationValidator validator, ISpecialCharacterCleanserService cleanser, ILogger <UpdateEpaOrganisationContactHandler> logger)
{
_registerRepository = registerRepository;
_validator = validator;
_cleanser = cleanser;
_logger = logger;
}
public RegisterUserPlatformController(IEmailSender emailService, IViewRenderService viewRenderService, IUserToolkitRepository userToolkitRepository, IRegisterRepository registerRepository)
{
_emailService = emailService;
_viewRenderService = viewRenderService;
_userToolkitRepository = userToolkitRepository;
_registerRepository = registerRepository;
}
/// <summary>
/// Constructor of StudentController.
/// </summary>
public StudentController(ICourseRepository courseRepository, IStudentRepository studentRepository,
IRegisterRepository registerRepository)
{
_courseRepository = courseRepository;
_studentRepository = studentRepository;
_registerRepository = registerRepository;
}
public MockedDummyRegisterRepository()
{
using (var mock = AutoMock.GetStrict())
{
mock.Mock <IRegisterRepository>().Setup(ireg => ireg.GetListOfEMails()).Returns(emails);
mock.Mock <IRegisterRepository>().Setup(ireg => ireg.GetListOfUserNames()).Returns(usernames);
mock.Mock <IRegisterRepository>().Setup(ireg => ireg.SaveUser(It.IsAny <User>(), It.IsAny <UserInfo>()))
.Callback((User user, UserInfo userinfo) =>
{
_user.userName = user.userName;
_user.password = user.password;
_userinfo.age = userinfo.age;
_userinfo.email = userinfo.email;
_userinfo.firstName = userinfo.firstName;
_userinfo.lastName = userinfo.lastName;
_userinfo.picture = userinfo.picture;
_userinfo.gender = userinfo.gender;
_userinfo.position = userinfo.position;
_userinfo.user = userinfo.user;
});
_registerRepository = mock.Create <IRegisterRepository>();
}
}
//private readonly IUserFilter userFilter;
public RegisterService(IRegisterRepository userRepo, IUnitOperation unitOp)
{
this.userRepository = userRepo;
//this.userRoleRepository = userRoleRepo;
this.unitOperation = unitOp;
//this.userFilter = uf;
}
public override void SetRepositories()
{
_Reposetory = new EditProfileRepository <EditProfileViewModel>(_MasterRepo, new DynamixService((U, P, A) =>
ExecuteQueryWithTypedParametersAndNetworkAccessAsync(U, P, A)));
photoRepo = new PhotoRepository(_MasterRepo);
_RegisterRepo = new RegisterRepository(_MasterRepo, null);
_selfieRepo = new SelfieRepository(_MasterRepo);
}
public WelcomeRepository(IMasterRepository masterRepository,
IRegisterRepository registerRepo,
ISelfieRepository selfieRepo)
: base(masterRepository)
{
_RegisterRepo = registerRepo;
_SelfieRepo = selfieRepo;
}
public RegisterController(IEmailSender emailService, IViewRenderService viewRenderService, IRegisterRepository registerRepository, ICustomSystemLog customSystemLog, IUserToolkitRepository userToolkitRepository)
{
_emailService = emailService;
_viewRenderService = viewRenderService;
_registerRepository = registerRepository;
_customSystemLog = customSystemLog;
_userToolkitRepository = userToolkitRepository;
}
public RegisterMoreController(IRegisterRepository rep, IRegisterApplicationService app, ILoggerFactory logger, EnviromentInfo env, CurrentUser user)
{
this._rep = rep;
this._app = app;
this._logger = logger.CreateLogger <RegisterMoreController>();
this._env = env;
this._user = user;
}
public RequestRepository(ApplicationContext context,
IHttpContextAccessor contextAccessor,
IRequestItemRepository requestItemRepository,
IRegisterRepository registerRepository) : base(context)
{
this.contextAccessor = contextAccessor;
this.requestItemRepository = requestItemRepository;
this.registerRepository = registerRepository;
}
public override void SetRepositories()
{
_Reposetory = new MyCoverRepository <MyCoverViewModel>(_MasterRepo);
_RegisterService = new RegisterService((U, P, A) =>
ExecuteQueryWithTypedParametersAndNetworkAccessAsync(U, P, A));
_DynamixService = new DynamixService((U, P, A) =>
ExecuteQueryWithTypedParametersAndNetworkAccessAsync(U, P, A));
_RegisterRepo = new RegisterRepository(_MasterRepo, _RegisterService, _DynamixService);
}
public void Configure(IApplicationBuilder app, IWebHostEnvironment env, IRegisterRepository registerRep)
{
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
else
{
app.UseExceptionHandler("/Error");
app.UseHsts();
}
app.UseHttpsRedirection();
app.UseStaticFiles();
app.UseRouting();
app.UseSession();
app.UseAuthorization();
app.Use(async(context, next) =>
{
if (!context.Session.Keys.Contains("AuthReady"))
{
context.Session.Set("AuthReady", "false");
}
await next.Invoke();
});
app.Use(async(context, next) =>
{
string CookieId;
string Email;
if (context.Request.Cookies.ContainsKey("CookieId")
&&
context.Request.Cookies.ContainsKey("Email"))
{
if (context.Request.Cookies.TryGetValue("CookieId", out CookieId)
&&
context.Request.Cookies.TryGetValue("Email", out Email))
{
var user = registerRep.GetUserByCookie(int.Parse(CookieId), Email);
if (!(user is null))
{
context.Session.Set <RegisterModel>("AuthUser", user);
context.Session.Set("AuthReady", "true");
}
}
}
await next.Invoke();
});
app.UseEndpoints(endpoints =>
{
endpoints.MapRazorPages();
});
}
public CreateEpaOrganisationHandler(IRegisterRepository registerRepository, IRegisterQueryRepository registerQueryRepository, IEpaOrganisationIdGenerator orgIdGenerator, ILogger <CreateEpaOrganisationHandler> logger,
ISpecialCharacterCleanserService cleanser, IEpaOrganisationValidator validator)
{
_registerRepository = registerRepository;
_registerQueryRepository = registerQueryRepository;
_logger = logger;
_cleanser = cleanser;
_organisationIdGenerator = orgIdGenerator;
_validator = validator;
}
public RegisterPresenter(IRegisterView view, IRegisterRepository registerRepository, IStagePresenter stagePresenter, Action openLoginView, IOption <User> userOption)
{
_view = view;
_registerRepository = registerRepository;
_stagePresenter = stagePresenter;
_openLoginView = openLoginView;
_userOption = userOption;
_view.OnRegisterButtonClick = Register;
}
public RequestController(IProductRepository productRepository,
IRequestRepository requestRepository,
IRequestItemRepository requestItemRepository,
IRegisterRepository registerRepository)
{
this.productRepository = productRepository;
this.requestRepository = requestRepository;
this.registerRepository = registerRepository;
this.requestItemRepository = requestItemRepository;
}
public RegisterRepositoryTests()
{
repository = new MockRepository(MockBehavior.Strict)
{
DefaultValue = DefaultValue.Mock
};
masterRepoMock = repository.Create <IMasterRepository>();
registerService = repository.Create <IRegisterService>();
dynamixService = repository.Create <IDynamixService>();
registerRepo = new RegisterRepository(masterRepoMock.Object, registerService.Object, dynamixService.Object);
}
public LoginHandler(ILogger <LoginHandler> logger,
IOrganisationQueryRepository organisationQueryRepository,
IContactQueryRepository contactQueryRepository, IContactRepository contactRepository,
IRegisterRepository registerRepository)
{
_logger = logger;
_organisationQueryRepository = organisationQueryRepository;
_contactQueryRepository = contactQueryRepository;
_contactRepository = contactRepository;
_registerRepository = registerRepository;
}
public OrderController(IProductRepository productRepository,
IOrderRepository orderRepository,
IProductOrderRepository productOrderRepository,
IRegisterRepository registerRepository,
UserManager <AppIdentityUser> userManager)
{
this.productRepository = productRepository;
this.orderRepository = orderRepository;
this.productOrderRepository = productOrderRepository;
this.registerRepository = registerRepository;
this.userManager = userManager;
}
public BusinessLogicTests()
{
_db = new State();
_db.Initialize();
_incomingRepository = new Repository <Incoming>(_db);
_consumptionRepository = new Repository <Consumption>(_db);
_remainNomenclatureRepository = new RemainNomenclatureRegisterRepository(_db);
_remainCostPrice = new RemainCostPriceRegisterRepository(_db);
_incomingService = new IncomingService(_incomingRepository, _remainNomenclatureRepository, _remainCostPrice);
_consumptionService = new ConsumptionService(_consumptionRepository, _remainNomenclatureRepository, _remainCostPrice, _db);
_remainNomenclatureBalance = new RemainNomenclatureBalanceRegisterRepository(_db);
_remainCostPriceBalance = new RemainCostPriceBalanceRegisterRepository(_db);
}
public OrderRepository(ApplicationContext context,
IHttpContextAccessor httpContextAccessor,
IConfiguration configuration,
IHttpHelper sessionHelper,
IRegisterRepository registerRepository,
UserManager <AppIdentityUser> userManager,
IReportHelper reportHelper) : base(context, configuration)
{
this.httpContextAccessor = httpContextAccessor;
this.httpHelper = sessionHelper;
this.registerRepository = registerRepository;
this.userManager = userManager;
this.reportHelper = reportHelper;
}
/// <summary>
/// Load your modules or register your services here!
/// </summary>
/// <param name="kernel">The kernel.</param>
private static void RegisterServices(IKernel kernel)
{
IRegisterRepository repRegister = null;
if (Startup.DbEngine == DbEngineEnum.SqlServer)
{
repRegister = new RegisterSqlServer();
}
if (Startup.DbEngine == DbEngineEnum.MongoDb)
{
repRegister = new RegisterMongo();
}
repRegister.Register(kernel);
RegisterAppServices.Register(kernel);
}
public EventService(IEventRepository eventRepository,
IEventTranslationRepository eventTranslationRepository,
IResourceService <SharedResource> sharedResourceService,
IResourceService <GhmWebsiteEventResource> websiteEventResourceService,
IConfiguration configuration,
IRegisterRepository registerRepository,
IEventDayRepository eventDayRepository,
IEventAlbumRepository eventAlbumRepository
)
{
_eventRepository = eventRepository;
_eventTranslationRepository = eventTranslationRepository;
_sharedResourceService = sharedResourceService;
_websiteEventResourceService = websiteEventResourceService;
_configuration = configuration;
_registerRepository = registerRepository;
_eventDayRepository = eventDayRepository;
_eventAlbumRepository = eventAlbumRepository;
}
public RegisterService(IRegisterRepository registerRepository,
IEventDayRegisterRepository eventDayRegisterRepository,
IAccompanyPersonRepository accompanyPersonRepository,
IEventRepository eventRepository,
IEventDayRepository eventDayRepository,
IConfiguration configuration,
IResourceService <SharedResource> sharedResourceService,
IResourceService <GhmWebsiteEventResource> websiteEventResourceService
)
{
_registerRepository = registerRepository;
_eventDayRegisterRepository = eventDayRegisterRepository;
_accompanyPersonRepository = accompanyPersonRepository;
_eventRepository = eventRepository;
_eventDayRepository = eventDayRepository;
_configuration = configuration;
_sharedResourceService = sharedResourceService;
_websiteEventResourceService = websiteEventResourceService;
}
public override void SetRepositories()
{
_RegisterService = new RegisterService((U, P, A) =>
ExecuteQueryWithTypedParametersAndNetworkAccessAsync(U, P, A));
_DynamixService = new DynamixService((U, P, A) =>
ExecuteQueryWithTypedParametersAndNetworkAccessAsync(U, P, A));
var _DynamixReturnService = new DynamixReturnService <List <DynamixContact> >((U, P, A) =>
ExecuteQueryWithReturnTypeAndNetworkAccessAsync <List <DynamixContact> >(U, P, A));
var _DynamixPolicyReturnService = new DynamixReturnService <DynamixPolicy>((U, P, A) =>
ExecuteQueryWithReturnTypeAndNetworkAccessAsync <DynamixPolicy>(U, P, A));
var _DynamixCommunityReturnService = new DynamixReturnService <DynamixCommunity>((U, P, A) =>
ExecuteQueryWithReturnTypeAndNetworkAccessAsync <DynamixCommunity>(U, P, A));
var _DynamixUserReturnService = new DynamixReturnService <GetUserReturnModel>((U, P, A) =>
ExecuteQueryWithReturnTypeAndNetworkAccessAsync <GetUserReturnModel>(U, P, A));
_RegisterRepo = new RegisterRepository(_MasterRepo, _RegisterService, _DynamixService, _DynamixReturnService,
_DynamixPolicyReturnService, _DynamixCommunityReturnService, _DynamixUserReturnService);
_SelfieRepo = new SelfieRepository(_MasterRepo);
_Reposetory = new WelcomeRepository(_MasterRepo, _RegisterRepo, _SelfieRepo);
}
public override void SetRepositories()
{
_Reposetory = new CongratulationsRepository <CongratulationsViewModel>(_MasterRepo);
RegisterService = new RegisterService((U, P, A) =>
ExecuteQueryWithTypedParametersAndNetworkAccessAsync(U, P, A));
var _DynamixService = new DynamixService((U, P, A) =>
ExecuteQueryWithTypedParametersAndNetworkAccessAsync(U, P, A));
var _DynamixReturnService = new DynamixReturnService <List <DynamixContact> >((U, P, A) =>
ExecuteQueryWithReturnTypeAndNetworkAccessAsync <List <DynamixContact> >(U, P, A));
var _DynamixPolicyReturnService = new DynamixReturnService <List <DynamixPolicy> >((U, P, A) =>
ExecuteQueryWithReturnTypeAndNetworkAccessAsync <List <DynamixPolicy> >(U, P, A));
var _DynamixUserReturnService = new DynamixReturnService <GetUserReturnModel>((U, P, A) =>
ExecuteQueryWithReturnTypeAndNetworkAccessAsync <GetUserReturnModel>(U, P, A));
RegisterRepository = new RegisterRepository(_MasterRepo, RegisterService, _DynamixService, _DynamixReturnService,
null, null, _DynamixUserReturnService);
nIUSSDService = new NIUSSDService <NIUSSDReturnModel>((U, P, A) =>
ExecuteQueryWithReturnTypeAndNetworkAccessAsync <NIUSSDReturnModel>(U, P, A));
_CellReposetory = new RegistrationCellphoneRepository(_MasterRepo, nIUSSDService);
}
public AuthRepository(ILogs ILogs,
IHttpContextAccessor IHttpContextAccessor,
IJwtConfigs JwtConfigs,
IEnvironmentConfigs IEnvironmentConfigs,
IFuncMenuRepository IFuncMenuRepository,
IOwnerRepository IOwnerRepository,
IRegisterRepository IRegisterRepository,
ILogRepository ILogRepository
)
{
_ILogs = ILogs;
_IHttpContextAccessor = IHttpContextAccessor;
_IEnvironmentConfigs = IEnvironmentConfigs;
_EnvironmentModel = _IEnvironmentConfigs.GetEnvironmentSetting();
_JwtConfigs = JwtConfigs;
_IFuncMenuRepository = IFuncMenuRepository;
_IOwnerRepository = IOwnerRepository;
_IRegisterRepository = IRegisterRepository;
_ILogRepository = ILogRepository;
}
public async Task <IActionResult> Balance(ControllerBase controller,
IRegisterRepository repo, int id)
{
try
{
string desc = GetControllerDescription(controller);
_logger.LogInfo(desc);
if (id < 1)
{
_logger.LogWarn($"{desc}: Empty request submitted");
return(controller.BadRequest());
}
var user = await _userService.GetCurrentUser();
if (user == null)
{
_logger.LogWarn($"{desc}: Invalid request submitted - Not a valid user");
return(controller.BadRequest());
}
var exists = await repo.Exists(id, user?.Id);
if (!exists)
{
_logger.LogWarn($"{desc}: Item with id {id} was not found or does not belong to {user?.Email}");
return(controller.NotFound());
}
var isSuccess = await repo.Balance(id, user?.Id);
if (!isSuccess)
{
return(InternalError(controller, $"{desc}: Balance failed"));
}
_logger.LogInfo($"{desc}: Balance Successful");
return(controller.Ok());
}
catch (Exception e)
{
return(InternalError(controller, $"Server Error: {e.Message} - {e.InnerException}"));
}
}
public RegisterIsSuitableValidation(IRegisterRepository rep)
{
//base.Add(Guid.NewGuid().ToString(), new Rule<Register>(Instance of is suitable,"message for user"));
}
public RegisterController()
{
_registerRepository = new RegisterRepository();
_registerMapper = new RegisterMapper();
}
private readonly IRegisterRepository _repository; // = new RegisterRepository();
#endregion Fields
#region Constructors
public AccountManagementController(IRegisterRepository repo)
{
_repository = repo;
}
