public async static Task <bool> IsExistsRole(IAdminRepository repo, RoleManager <IdentityRole> roleManager, string gdprRolename)
{
MxReturnCode <bool> rc = new MxReturnCode <bool>("IdentityDb.IsExistsRole()", false);
if ((repo == null) || (roleManager == null) || (gdprRolename == null))
{
rc.SetError(3160401, MxError.Source.Param, "repo, roleManager or rolename is null", MxMsgs.MxErrUnexpected);
}
else
{
try
{
var identityRolename = AdminRepository.GetIdentityRolename(gdprRolename);
//check identity
var result = await repo.GetRoleAsync(gdprRolename);
rc += result;
if (result.IsSuccess())
{
rc.SetResult(true);
}
else
{
rc.SetResult(false);
}
}
catch (Exception e)
{
rc.SetError(3160402, MxError.Source.Exception, e.Message, MxMsgs.MxErrUnknownException, true);
}
}
return(rc.GetResult());
}
public AdminController(IBookingRepository bookingRepository, IAdminRepository adminRepository)
{
_logger = NLog.LogManager.GetCurrentClassLogger();
_adminRepository = adminRepository;
_bookingRepository = bookingRepository;
}
public AdminService(
IWCloudContext <AdminService> _context,
IAdminRepository adminRepository)
{
this._context = _context;
this.adminRepository = adminRepository;
}
public ProgramController(
ILogger <ProgramController> logger,
IAdminRepository adminReposiotry)
{
this.logger = logger ?? throw new ArgumentNullException(nameof(logger));
this.adminReposiotry = adminReposiotry ?? throw new ArgumentNullException(nameof(adminReposiotry));
}
public LunaBLL()
{
_movieRepository = new MovieRepository();
_userRepository = new UserRepository();
_orderRepository = new OrderRepository();
_adminRepository = new AdminRepository();
}
private void attachUserToContext(HttpContext context, IAdminRepository AdminRepository, string token)
{
try
{
var tokenHandler = new JwtSecurityTokenHandler();
var key = Encoding.ASCII.GetBytes(_appSettings.Secret);
tokenHandler.ValidateToken(token, new TokenValidationParameters
{
ValidateIssuerSigningKey = true,
IssuerSigningKey = new SymmetricSecurityKey(key),
ValidateIssuer = false,
ValidateAudience = false,
// set clockskew to zero so tokens expire exactly at token expiration time (instead of 5 minutes later)
ClockSkew = TimeSpan.Zero
}, out SecurityToken validatedToken);
var jwtToken = (JwtSecurityToken)validatedToken;
var adminId = int.Parse(jwtToken.Claims.First(x => x.Type == "adminId").Value);
// attach user to context on successful jwt validation
context.Items["Admin"] = AdminRepository.GetById(adminId);
}
catch
{
// do nothing if jwt validation fails
// user is not attached to context so request won't have access to secure routes
}
}
public EmailSendedRecordDomainService(IProjectRepository projectRepository, IEmailSendedRecordRepository emailSendedRecordRepository, IAdminRepository adminRepository, ISysConfigCache sysConfigCache)
{
_projectRepository = projectRepository;
_emailSendedRecordRepository = emailSendedRecordRepository;
_adminRepository = adminRepository;
_sysConfigCache = sysConfigCache;
}
public AdminController(IAdminRepository repo, UserManager <ApplicationUser> userManager, RoleManager <IdentityRole> roleManager, IMapper mapper)
{
_repo = repo;
_userManager = userManager;
_mapper = mapper;
_roleManager = roleManager;
}
protected override void Initialize(HttpControllerContext controllerContext)
{
base.Initialize(controllerContext);
_reportingRepo = new ReportingRepository(PowerBiAppContext, Tenant);
_adminRepo = new AdminRepository(PowerBiAppContext, Tenant);
_veracityApiHelper = new VeracityApiHelper();
}
public InsertResponse CreateAdmin(AdminModel admin)
{
try
{
IAdminRepository adminRepository = RepositoryClassFactory.GetInstance().GetAdminRepository();
Admin _admin = adminRepository.FindByUserName(admin.UserName);
if (_admin != null)
{
return(new InsertResponse
{
ErrorCode = (int)ErrorCode.Error,
Message = Resources.Resource.msg_username_exists
});
}
object id = adminRepository.Insert(MapperUtil.CreateMapper().Mapper.Map <AdminModel, Admin>(admin));
return(new InsertResponse
{
InsertID = id.ToString(),
ErrorCode = (int)ErrorCode.None,
Message = Resources.Resource.msg_create_success
});
}
catch (Exception ex)
{
return(new InsertResponse
{
ErrorCode = (int)ErrorCode.Error,
Message = ex.Message
});
}
}
public AdminController(IAdminRepository _adminRepository, ISliderRepository _sliderRepository, IEventsRepository _eventsRepository, IMomentsRepository _momentsRepository)
{
adminRepository = _adminRepository;
sliderRepository = _sliderRepository;
eventsRepository = _eventsRepository;
momentsRepository = _momentsRepository;
}
public GetActivitiesByRoleIdQueryHandler(IAdminRepository adminRepository, DataContext dataContext,
ILoggerService loggerService)
{
_adminRepository = adminRepository;
_logger = loggerService;
_context = dataContext;
}
public BlogService(IBlogRepository blogRepository, MarkdownTransformer markdownTransformer, RazorTransformer razorTransformer, IAdminRepository adminRepository)
{
_blogRepository = blogRepository;
_markdownTransformer = markdownTransformer;
_razorTransformer = razorTransformer;
_adminRepository = adminRepository;
}
public AdminController()
{
_admin = new EFAdminRepository();
_avm = new EFAVMRepository();
_marka = new EFMarkaRepository();
_sehir = new EFSehirRepository();
}
public AdminApplication(IAdminRepository adminRepository, IAdminDomainService adminDomainService, IAdminDetailDomainService adminDetailDomainService, IOperateLogDomainService operateLogDomainService)
{
_adminRepository = adminRepository;
_adminDomainService = adminDomainService;
_adminDetailDomainService = adminDetailDomainService;
_operateLogDomainService = operateLogDomainService;
}
public AdminService(IAdminRepository adminrepo, IRentACarAdminRepository repo, IUnitOfWork unitOfWork, UserManager <AuthentificationUser> manager)
{
this.manager = manager;
this.repo = repo;
this.unitOfWork = unitOfWork;
this.repo2 = adminrepo;
}
public AdminService(NLog.Logger logger, IAdminRepository adminRepository)
{
_logger = logger;
_adminRepository = adminRepository;
_logger.Trace(LoggerHelper.InitializeClassMessage());
}
public AdminService(IAdminRepository adminRepository,
IAuthService authService,
ILogger <AdminService> logger)
{
_adminRepository = adminRepository;
_authService = authService;
}
public TestDataGeneratorController(
ICommandCoordinator commandCoordinator,
IAdminRepository adminRepository,
IDataConsumerRepository dataConsumerRepository,
IDataCoordinatorRepository dataCoordinatorRepository,
IDataOwnerRepository dataOwnerRepository,
IDataVerifierRepository dataVerifierRepository,
ISystemConfiguratorRepository systemConfiguratorRepository,
IDataCollectors dataCollectors,
IGreetingHistories greetingHistories
)
{
_commandCoordinator = commandCoordinator;
_adminRepository = adminRepository;
_dataCoordinatorRepository = dataCoordinatorRepository;
_dataOwnerRepository = dataOwnerRepository;
_dataVerifierRepository = dataVerifierRepository;
_systemConfiguratorRepository = systemConfiguratorRepository;
_dataConsumerRepository = dataConsumerRepository;
_dataCollectors = dataCollectors;
_greetingHistories = greetingHistories;
}
public static string GetAdminName(string adminId)
{
IAdminRepository adminRepository = RepositoryClassFactory.GetInstance().GetAdminRepository();
Admin admin = adminRepository.FindByID(adminId);
return(admin != null ? !string.IsNullOrEmpty(admin.LastName) ? admin.LastName : admin.FirstName : adminId);
}
public LoginController(IAdminRepository repository, AdminService service, AdminAuthService adminAuthService, ModulService modulService)
{
this.repository = repository;
this.service = service;
this.adminAuthService = adminAuthService;
this.modulService = modulService;
}
public AuthenticationController(ITokenRepository tokenRepository, IAdminRepository adminRepository, ITeacherRepository teacherRepository, IStudentRepository studentRepository)
{
_tokenRepository = tokenRepository ?? throw new ArgumentNullException(nameof(tokenRepository));
_adminRepository = adminRepository ?? throw new ArgumentNullException(nameof(adminRepository));
_teacherRepository = teacherRepository ?? throw new ArgumentNullException(nameof(teacherRepository));
_studentRepository = studentRepository ?? throw new ArgumentNullException(nameof(studentRepository));
}
public DelegateAcademicHandler(IAdminRepository adminRepository,
IAcademicRepository academicRepository, ISubjectRepository subjectRepository)
{
_adminRepository = adminRepository;
_academicRepository = academicRepository;
_subjectRepository = subjectRepository;
}
public AdminsController(
IAdminRepository adminRepository,
IMapper mapper)
{
_adminRepository = adminRepository;
_mapper = mapper;
}
public PushController(IAdminRepository adminRepository, ISurveyRepository surveyRepository,
IPushRepository pushRepository)
{
_adminRepository = adminRepository;
_surveyRepository = surveyRepository;
_pushRepository = pushRepository;
}
public AdminById(
IAdminRepository adminRepository,
Guid staffUserId)
{
_adminRepository = adminRepository;
StaffUserId = staffUserId;
}
public AdminController(UserManager <User> userManager, RoleManager <Role> roleManager, IMapper mapper, IAdminRepository repo)
{
_userManager = userManager;
_roleManager = roleManager;
_mapper = mapper;
_repo = repo;
}
public GeneralUserService(IAdminRepository repo1, IUserRepository userRepository, IAirlineAdminRepository airlineAdminRepository, IRentACarAdminRepository repo)
{
this.userRepository = userRepository;
this.airlineAdminRepository = airlineAdminRepository;
this.repo = repo;
this.repo2 = repo1;
}
public MainController(
IWindowFormsFactory formsFactory,
IPlayerRepository playerRepository,
ITrainerRepository trainerRepository,
IAdminRepository adminRepository,
ITrainingRepository trainingRepository,
ITeamRepository teamRepository,
ITransactionRepository transactionRepository,
IAdminController adminController,
IPlayerController playerController,
ITrainerController trainerController,
IAuthController authController
)
{
_formsFactory = formsFactory;
_playerRepository = playerRepository;
_trainerRepository = trainerRepository;
_adminRepository = adminRepository;
_trainingRepository = trainingRepository;
_teamRepository = teamRepository;
_transactionRepository = transactionRepository;
_adminController = adminController;
_playerController = playerController;
_trainerController = trainerController;
_authController = authController;
}
public UserService(
IAdminRepository adminRepository,
AppSettings appSettings)
{
_adminRepository = adminRepository;
_appSettings = appSettings;
}
public AdminModule(IAdminRepository adminRepo, ICardsRepository cardsRepository)
: base("/admin")
{
this.adminRepository = adminRepo;
this.cardsRepository = cardsRepository;
FixCardLabel();
DownloadCardImage();
}
public HomeController()
{
/* Real Repository */
riderRepo = new Domain.Concrete.RiderRepository();
adminRepo = new Domain.Concrete.AdminRepository();
/* Mock Data */
//Rider rider1 = new Rider() { FName = "Nathan", LName = "Healea", DOB = DateTime.Parse("1/1/2011"), Address = "11111 Address St", Age = 21, City = "Eugene", EMail = "*****@*****.**", Phone = "541-555-5555", ParentReleaseSigned = false, State = "Oregon", Zip = 117, ReleaseSigned = true };
// riderRepo.addRider(rider1);
}
public ClientEventRecipientsFacade(
IAdminRepository admins,
IManagerRepository managers,
IClientRepository clients,
IEventEmailRecipient recipients)
{
_admins = admins;
_managers = managers;
_clients = clients;
_recipients = recipients;
}
public void InicializarTest()
{
_adminRepository = new EFAdminRepository(_vestContext);
_inserirAdm = new Admin()
{
Email = "*****@*****.**",
Login = "******",
Senha = "123",
NomeTratamento = "João Effting"
};
}
public void InicializarTest()
{
// Injeção de dependência manual
_adminRepository = new AdminRepository(_vestContext);
_entidade = new Admin
{
NomeTratamento = "Marcelo J. Both",
Email = "*****@*****.**",
Login = "******",
Senha = "123456"
};
}
public AwbEventRecipientsFacade(
IAdminRepository admins,
IManagerRepository managers,
IBrokerRepository brokers,
IAwbRepository awbs,
IEventEmailRecipient recipients)
{
_admins = admins;
_managers = managers;
_brokers = brokers;
_awbs = awbs;
_recipients = recipients;
}
public BillManager(
IApplicationRepository applications,
ISettingRepository settings,
IBillRepository bills,
IBillPdf pdf,
IAdminRepository admins,
IMailSender mail)
{
_applications = applications;
_settings = settings;
_bills = bills;
_pdf = pdf;
_admins = admins;
_mail = mail;
}
public void MyTestInitialize()
{
AppDomain.CurrentDomain.SetData("DataDirectory", Path.Combine(AppDomain.CurrentDomain.BaseDirectory, ""));
//DbContextManager.InitStorage(new SimpleDbContextStorage());
CommonConfig.Instance()
.ConfigureDbContextStorage(new SimpleDbContextStorage())
.ConfigureData<MyDbContext>("DefaultConnection")
.ConfigureData<SysManagerContext>("DefaultConnection1");
//config.ConfigureData<MyDbContext>("DefaultConnection");
this.AdminRepository = new AdminRepository("DefaultConnection1");
}
public UserService(IUserRepository users,
IAdminRepository admins,
IManagerRepository managers,
ICarrierRepository carriers,
ISenderRepository senders,
IForwarderRepository forwarders,
IBrokerRepository brokers)
{
_users = users;
_admins = admins;
_managers = managers;
_carriers = carriers;
_senders = senders;
_forwarders = forwarders;
_brokers = brokers;
}
public IdentityService(
IUserRepository users,
IAdminRepository admins,
IManagerRepository managers,
ICarrierRepository carriers,
ISenderRepository senders,
IClientRepository clients,
IForwarderRepository forwarders,
IBrokerRepository brokers)
{
if(HttpContext.Current == null)
throw new NotSupportedException("UserHolder works only when the HttpContext.Current is presented");
_users = users;
_admins = admins;
_managers = managers;
_carriers = carriers;
_senders = senders;
_clients = clients;
_forwarders = forwarders;
_brokers = brokers;
}
public ApplicationEventRecipientsFacade(
IAwbRepository awbs,
IApplicationRepository applications,
IAdminRepository admins,
IManagerRepository managers,
ISenderRepository senders,
IClientRepository clients,
ICarrierRepository carriers,
IForwarderRepository forwarders,
IBrokerRepository brokers,
IEventEmailRecipient recipients)
{
_awbs = awbs;
_applications = applications;
_admins = admins;
_managers = managers;
_senders = senders;
_clients = clients;
_carriers = carriers;
_forwarders = forwarders;
_brokers = brokers;
_recipients = recipients;
}
public AdminLogikk()
{
_repository = new AdminRepository();
}
public AdminLogikk(IAdminRepository stub)
{
_repository = stub;
}
public AdminNHANVIENService(IAdminRepository<NHANVIEN> repository, IUnitOfWork unitOfWork)
: base(repository, unitOfWork)
{
this.Repository = repository;
}
public AccountController(IAdminRepository adminRepo)
{
_adminRepo = adminRepo;
}
public InvestorController(IInvestorRepository investorRepository, IAdminRepository adminRepository)
{
InvestorRepository = investorRepository;
AdminRepository = adminRepository;
}
public AdminProvider(IAdminRepository repository)
{
Repository = repository;
}
public ProfileController(IAdminRepository adminRepository, SiteDbContext context)
{
AdminRepository = adminRepository;
Context = context;
}
public AdminCompanyService(IAdminRepository<Company> repository, IUnitOfWork unitOfWork)
: base(repository, unitOfWork)
{
this.Repository = repository;
}
public AdminHelper()
{
_iAdminRepository = DependencyResolver.GetAdminInstance();
}
public AdminController(IAdminRepository AdminRepo, ITrashRepository TrashRepo)
{
AdminRepository = AdminRepo;
TrashRepository = TrashRepo;
}
public AdminDICHVUService(IAdminRepository<DICHVU> repository, IUnitOfWork unitOfWork)
: base(repository, unitOfWork)
{
this.Repository = repository;
}
public AdminOrderService(IAdminRepository<Order> repository, IUnitOfWork unitOfWork)
: base(repository, unitOfWork)
{
this.Repository = repository;
}
public AdminProductCommentService(IAdminRepository<ProductComment> repository, IUnitOfWork unitOfWork)
: base(repository, unitOfWork)
{
this.Repository = repository;
}
public AdminService(IAdminRepository repository)
{
this.repository = repository;
}
public HomeController(IRepository repository, NinjaLista.Web.CaptchaServices.ICaptchaService captchaService,IAdminRepository adminrepository)
{
_Repository = repository;
_adminRepository = adminrepository;
this.captchaService = captchaService;
}
public CustomAutenticacaoProvider(IAdminRepository repository)
{
adminRepository = repository;
}
public AdminService(IAdminRepository adminRepository)
{
this.adminRepository=adminRepository;
}
public AdminModel(IAdminRepository repository)
{
adminRepository = repository;
}
public UserController(IAdminRepository adminRepo)
{
_adminRepo = adminRepo;
}
