public OrderBLL(IOrderRepo stub)
{
_repo = stub;
_productrepo = new ProductRepoStub();
_customerrepo = new CustomerRepoStub();
_accountrepo = new AccountRepoStub();
}
public CustomerInfoController(ILogger <HomeController> logger, IAccountRepo iAcc, IRoutesRepo iRou, IBookingRepo iBook)
{
_logger = logger;
_IAcc = iAcc;
_IRou = iRou;
_IBook = iBook;
}
public static async Task <Response> BeforeRequestHandler(IAccountRepo accountRepo, NancyContext ctx, CancellationToken token)
{
if (!ctx.Request.Url.ToString().Contains("/api/"))
{
return(null);
}
// do not check for session key if login
if (ctx.Request.Url.ToString().Contains("/account/"))
{
return(null);
}
// check if header contains session key
var skeys = ctx.Request.Headers["jwt"].ToList();
if (skeys.Count != 1)
{
throw new UserException(strings.InvalidSessionKey);
}
// request ctx
var userid = await accountRepo.CheckSession(skeys[0]);
ctx.Request.Session = new Session();
ctx.Request.Session["UserId"] = userid;
return(null);
}
public TransactionController()
{
context = new BankContext();
transactionRepo = new EFTransactionRepo(context);
customerRepo = new EFCustomerRepo(context);
accountRepo = new EFAccountRepo(context);
}
public CustomerBLL()
{
_repo = new CustomerRepo();
_accountrepo = new AccountRepo();
_orderrepo = new OrderRepo();
_productrepo = new ProductService();
}
public AccountAPI(
IAccountRepo accountRepo,
ILogger logger)
{
this._accountRepo = accountRepo;
this._logger = logger;
}
public AccountsController(
IAccountRepo <AccountDto, AccountDtoFilter> accountRepo,
ICurrencyRepo <CurrencyDto> currencyRepo)
{
_accountRepo = accountRepo;
_currencyRepo = currencyRepo;
}
public Module(CommandService service, IConfigurationRoot config, ISteamAPIRepo steamAPIRepo, IAccountRepo accRepo)
{
_service = service;
_config = config;
_steamRepo = steamAPIRepo;
_accRepo = accRepo;
}
public VerifyUserAccountController(IUserRepo urep, IAuthProvider auth, IAccountRepo account, ICCFolderRepo folderRep)
{
userRepository = urep;
authProvider = auth;
accRepository = account;
CCFolderRepository = folderRep;
}
public OrderBLL()
{
_repo = new OrderRepo();
_productrepo = new ProductRepo();
_customerrepo = new CustomerRepo();
_accountrepo = new AccountRepo();
}
public ExO365Controller(IFolderRepo folderRepo, IFolderFieldRepo ffRepo, ICredentialRepo credRepo,IAccountRepo accRepo)
{
folderRepository = folderRepo;
ffRepository = ffRepo;
credRepository = credRepo;
accRepository = accRepo;
}
public UserController(UserManager <AppUser> userManager,
SignInManager <AppUser> signInManager, IUserRepo userRepo, IAccountRepo acctRepo)
{
this.userManager = userManager;
this.signInManager = signInManager;
_UserRepo = userRepo;
_AcctRepo = acctRepo;
}
public TestController()
{
context = new BankContext();
context.Configuration.LazyLoadingEnabled = false;
transactionRepo = new EFTransactionRepo(context);
customerRepo = new EFCustomerRepo(context);
accountRepo = new EFAccountRepo(context);
}
public RegisterModel(ILogger <RegisterModel> logger,
IAccountRepo accountRepo,
IProfileRepo profileRepo)
{
_logger = logger;
_accountRepo = accountRepo;
_profileRepo = profileRepo;
}
public AdminController(
ILogger <AdminController> logger,
IAccountRepo _accountRepository,
IConfiguration _configuration)
{
_logger = logger;
accountRepository = _accountRepository;
configuration = _configuration;
}
public OperationsController(
IOperationRepo <OperationDto, OperationDtoFilter> operationRepo,
IAccountRepo <AccountDto, AccountDtoFilter> accountRepo,
IOperationTypeRepo <OperationTypeDto> operationTypeRepo
)
{
_operationRepo = operationRepo;
_accountRepo = accountRepo;
_operationTypeRepo = operationTypeRepo;
}
public Edit(IAccountRepo accountRepo,
IProfileRepo profileRepo,
IRoleRepo roleRepo,
IRoleMappingRepo roleMappingRepo)
{
_accountRepo = accountRepo;
_profileRepo = profileRepo;
_roleRepo = roleRepo;
_roleMappingRepo = roleMappingRepo;
}
public SignInService(IAccountRepo accountRepo,
IRoleRepo roleRepo,
IProfileRepo profileRepo,
ILogger <SignInService> logger)
{
_accountRepo = accountRepo;
_roleRepo = roleRepo;
_profileRepo = profileRepo;
_logger = logger;
}
public AccountController(IUserRepo userRepo,
IAccountRepo accountRepo,
IMapper mapper,
ILogger <UserController> logger)
{
_userRepo = userRepo;
_accountRepo = accountRepo;
_mapper = mapper;
_logger = logger;
}
public HelperFunctions()
{
this.accountRepo = new EFAccountRepo();
this.planRepository = new EFPlanRepo();
this.userRepository = new EFUserRepo();
this.purchRepository = new EFPurchasedProdRepo();
this.CCFolderRepository = new EFCCFolderRepo();
this.featureRepository = new EFFeatureRepo();
this.CCConnectionRepository = new EFCCConnectionsRepo();
this.CCItemRepository = new EFCCItemRepo();
}
public HelperFunctions(IAccountRepo account, IPlanRepo plan, IUserRepo user, IPurchasedFeatureRepo purch, ICCFolderRepo folder, IFeatureRepo feature, ICCConnectionsRepo CCConnection, ICCItemRepo CCItem)
{
accountRepo = account;
planRepository = plan;
userRepository = user;
purchRepository = purch;
CCFolderRepository = folder;
featureRepository = feature;
CCConnectionRepository = CCConnection;
CCItemRepository = CCItem;
}
public CronJobController(IAccountRepo accRepo ,INotificationManager notifMgr, IUserRepo urep,ICCItemRepo item,ICCFolderRepo fold)
{
CCUserRepository = urep;
//CCplanRepository = pRepo;
CCaccountRepo = accRepo;
notifManager = notifMgr;
CCItemRepository = item;
CCFolderRepository = fold;
//CCpurchRepository = purRepo;
//this.CCaccountRepo = new
}
//IPurchasedFeatureRepo CCpurchRepository;
public CronJobController()
{
CCUserRepository = new EFUserRepo();
CCItemRepository = new EFCCItemRepo();
CCFolderRepository = new EFCCFolderRepo();
//CCplanRepository = pRepo;
//CCaccountRepo = accRepo;
//CCpurchRepository = purRepo;
this.CCaccountRepo = new EFAccountRepo();
this.notifManager = new EmailNotificationManager();
}
public LoginController(IAuthProvider auth, IUserRepo userRepo, ICCFolderRepo folder, IAccountRepo account, ICCTokenRepo token, INotificationManager notifMgr, ICCItemRepo item, ICCErrorLogRepo errorlogs)
{
authProvider = auth;
userRepository = userRepo;
CCFolderRepository = folder;
accRepository = account;
CCTokenRepository = token;
notifManager = notifMgr;
items = item;
CCErrorLogRepository = errorlogs;
}
public void Init()
{
var accList = new List <Account>();
accList.Add(new Account {
AccountNumber = 1234, Balance = 20
});
accList.Add(new Account {
AccountNumber = 2345, Balance = 10
});
accountRepo = new AccountRepo(accList);
}
public UserAdminController(
IWebHostEnvironment _webHostEnvironment,
ILogger <UserAdminController> _logger,
IAccountRepo _accountRepository,
IStationRepo _stationRepository,
IRoleRepo _roleRepository)
{
webHostEnvironment = _webHostEnvironment;
logger = _logger;
accountRepository = _accountRepository;
stationRepository = _stationRepository;
roleRepository = _roleRepository;
}
public SignUpController(IPlanRepo repo, IAccountRepo accRepo, IFeatureRepo featureRepo, IUserRepo userRepo, IPurchasedFeatureRepo ppRepo, IAuthProvider auth, ICCFolderRepo folder, ICCTokenRepo token, INotificationManager notifMgr)
{
planRepository = repo;
accountRepository = accRepo;
featureRepository = featureRepo;
userRepository = userRepo;
ppRepository = ppRepo;
authProvider = auth;
CCFolderRepository = folder;
CCTokenRepository = token;
notifManager = notifMgr;
//SetConnectionString();
}
public AccountRepoTests()
{
_configuration = new ConfigurationBuilder()
.AddUserSecrets <AccountRepoTests>()
.Build();
var connectionString = _configuration["ItaBankConnectionString"];
var builder = new DbContextOptionsBuilder <ItaBankContext>();
builder.UseSqlServer(connectionString);
_context = new ItaBankContext(builder.Options);
_accountRepo = new AccountRepo(_context);
}
public Supervisor(IMapper mapper, ICustomerRepo ICustomerRepo,
IAccountRepo IAccountRepo, ICurrencyRepo ICurrencyRepo,
IAccountTypeRepo IAccountTypeRepo, ICurrencyRatioRepo ICurrencyRatioRepo,
IOperationRepo IOperationRepo, ITransactionRepo ITransactionRepo
)
{
_mapper = mapper;
_ICustomerRepo = ICustomerRepo;
_IAccountRepo = IAccountRepo;
_ICurrencyRepo = ICurrencyRepo;
_IAccountTypeRepo = IAccountTypeRepo;
_ICurrencyRatioRepo = ICurrencyRatioRepo;
_IOperationRepo = IOperationRepo;
_ITransactionRepo = ITransactionRepo;
}
public void initNonExistingRepo(bool withUnitOfWork = false)
{
// Als we een repo met UoW willen gebruiken en als er nog geen uowManager bestaat:
// Dan maken we de uowManager aan en gebruiken we de context daaruit om de repo aan te maken.
if (withUnitOfWork)
{
if (uowManager == null)
{
uowManager = new UnitOfWorkManager();
repo = new AccountRepo(uowManager.UnitOfWork);
}
}
// Als we niet met UoW willen werken, dan maken we een repo aan als die nog niet bestaat.
else
{
repo = (repo == null) ? new AccountRepo() : repo;
}
}
// int totalconnections;
public AdminController(IAuthProvider auth, IAccountRepo accRepo, ICCGroupRepo group, ICCGroupFieldRepo groupfield, IUserRepo urep, ICCFolderFieldRepo field, IPlanRepo pRepo, IUserRepo user, ICCItemRepo items, IPurchasedFeatureRepo purRepo, INotificationManager notifMgr, IFolderRepo folderRep, IFeatureRepo featureRep, ICCFolderRepo ccfolder, ICCItemRepo contacts, ICCConnectionsRepo subscription, ICCErrorLogRepo errorlogs, ICCHealthMsgs healthMsgs)
{
authProvider = auth;
userRepository = urep;
planRepository = pRepo;
accountRepo = accRepo;
CCFieldRepository = field;
purchRepository = purRepo;
notifManager = notifMgr;
folderRepo = folderRep;
featureRepository = featureRep;
CCFolderRepository = ccfolder;
CCContactRepository = contacts;
CCConnectionRepository = subscription;
CCErrorLogRepository = errorlogs;
CCUserRepository = user;
CCItemRepository = items;
CCHealthMsgsRepository = healthMsgs;
CCGroupRepository = group;
CCGroupFieldRepository = groupfield;
}
public FolderController(ICCFolderRepo folder, ICCFolderFieldRepo field, ICCItemRepo Item, ICCFieldValuesRepo fieldvalue, IAccountRepo account,
ICCGroupRepo group, ICCGroupFieldRepo groupfield, ICCLayoutRepo layout, ICCLayoutGroupRepo layoutgroup, ICCConnectionsRepo subscription,
ICredentialRepo credential, ICCFieldMappingsRepo fieldmapping, ICCNoteRepo note, ICCHistoryLogRepo historyLog,IPlanRepo plan,IFeatureRepo feature)
{
CCFolderRepository = folder;
CCFieldRepository = field;
CCItemRepository = Item;
CCFieldValueRepository = fieldvalue;
accRepository = account;
CCGroupRepository = group;
CCGroupFieldRepository = groupfield;
CCLayoutRepository = layout;
CCLayoutGroupRepository = layoutgroup;
CCConnectinRepository = subscription;
CCCredentialRepository = credential;
CCFieldMappingsRepository = fieldmapping;
CCNoteRepository = note;
CCHistoryLogRepository = historyLog;
planRepository = plan;
featureRepository = feature;
}
public void SettingUp()
{
_filePath = "abstractPath.txt";
_user = new User()
{
UserGuid = Guid.NewGuid(), Username = "******", AccountGuid = new List <Guid>()
{
Guid.NewGuid()
}
};
_users = new List <User>()
{
_user,
new User()
{
UserGuid = Guid.NewGuid(), Username = "******", AccountGuid = new List <Guid>()
}
};
_fakeIUserRepo = A.Fake <IUserRepo>();
_fakeIAccountRepo = A.Fake <IAccountRepo>();
}
//
// GET: /CorporateContactsAdmin/
public CorporateContactsAdminController(ICCConnectionsRepo connection, IAccountRepo account, ICCErrorLogRepo errLog, ICCFolderRepo folder, ICCItemRepo items,
ICCFolderFieldRepo field,ICCFieldValuesRepo fieldvalue, ICCGroupRepo group, ICCGroupFieldRepo groupfield, ICCLayoutRepo layout, ICCLayoutGroupRepo layoutgroup,
ICredentialRepo credential, ICCFieldMappingsRepo fieldmapping, ICCNoteRepo note, ICCSyncFieldsRepo syncFields, ICCSyncItems syncItems, IUserRepo user, ICCHealthMsgs healthMsgs)
{
CCConnectionRepository = connection;
CCAccRepository = account;
CCErrorLogRepository = errLog;
CCFolderRepository = folder;
CCItemRepository = items;
CCFieldRepository = field;
CCFieldValueRepository = fieldvalue;
CCGroupRepository = group;
CCGroupFieldRepository = groupfield;
CCLayoutRepository = layout;
CCLayoutGroupRepository = layoutgroup;
CCCredentialRepository = credential;
CCFieldMappingsRepository = fieldmapping;
CCNoteRepository = note;
CCSyncFieldsRepository = syncFields;
CCSyncItemsRepository = syncItems;
CCUserRepository = user;
CCHealthMsgsRepository = healthMsgs;
}
public async Task <IActionResult> Login([FromBody] LoginRequest request, [FromServices] IAccountRepo accountRepo)
{
try
{
var context = await _interaction.GetAuthorizationContextAsync(request.ReturnUrl);
if (context != null)
{
var userProfile = await accountRepo.GetAccountAsync(request.Username, request.Password);
if (userProfile != null && context != null)
{
var user = new IdentityServerUser(userProfile.User.UID.ToString());
user.DisplayName = userProfile.DisplayName;
user.AdditionalClaims = new List <Claim>
{
new Claim(JwtClaimTypes.Name, userProfile.User.Name),
new Claim(JwtClaimTypes.Email, userProfile.Email)
};
await HttpContext.SignInAsync(user);
return(new JsonResult(new { RedirectUrl = request.ReturnUrl, IsOk = true }));
}
}
return(Unauthorized());
}
catch (UserAccountException ex)
{
return(Unauthorized(ex.Message));
}
catch (Exception ex)
{
return(InternalServerError(ex));
}
}
//
// GET: /Stripe/
//public HttpResponseMessage Index()
//{
// //return View();
// return new HttpResponseMessage() { StatusCode = System.Net.HttpStatusCode.OK };
//}
//public int test2(string tt,InvoiceCreatedRequest request)
//{
// var ttt = request;
// return 1;
// //return Json("Sucess", JsonRequestBehavior.AllowGet);
//}
public StripeController()
{
this.notifManager = new EmailNotificationManager();
this.CCaccountRepo = new EFAccountRepo();
CCUserRepository = new EFUserRepo();
}
public EFUserRepo()
{
this.accRepository = new EFAccountRepo();
}
public AccountService(IAccountRepo accountRepo, ExchangeRateClient rateClient, IMapper mapper)
{
_accountRepo = accountRepo;
_mapper = mapper;
_client = rateClient;
}
public AdapterRepo(IUserRepo userRepo, IAccountRepo accountRepo)
{
_userRepo = userRepo;
_accountRepo = accountRepo;
}
public EFUserRepo( IAccountRepo acc)
{
accRepository = acc;
}
public BankerController(ICustomerRepo customerRepo, IAccountRepo accountRepo, IBankerRepo bankerRepo)
{
this.customerRepo = customerRepo;
this.accountRepo = accountRepo;
this.bankerRepo = bankerRepo;
}
public AccountProvider(IAccountRepo accountRepo)
{
_accountRepo = accountRepo;
}
public AccountsController(IAccountRepo newRepo, ILogger <AccountsController> newLogger)
{
_logger = newLogger;
_repo = newRepo;
}
public StripeController(INotificationManager notifMgr, IAccountRepo accRepo, IUserRepo urep)
{
notifManager = notifMgr;
CCUserRepository = urep;
CCaccountRepo = accRepo;
}
public AccountService(IAccountRepo accountRepo)
{
_accountRepo = accountRepo;
}
public AccountManager(IAccountRepo accountRepo)
{
_accountRepo = accountRepo;
}
public TransferablesController(IAccountRepo repoAccount, IAccountTypeRepo repoType, ILogger <TransferablesController> logger)
{
_repoAccountType = repoType;
_repoAccount = repoAccount;
_logger = logger;
}
public AccountBLL()
{
_repo = new AccountRepo();
_customerrepo = new CustomerRepo();
}
public AccountBLL(IAccountRepo stub)
{
_repo = stub;
_customerrepo = new CustomerRepoStub();
}
public LoginService(IAccountRepo accountRepo, ILogger logger)
{
_accountRepo = accountRepo;
_logger = logger;
}
