protected override void Context()
{
AccountService = MockRepository.GenerateStub<IAccountService>();
Identity = new FakeIdentity(Username);
_user = new FakePrincipal(Identity, null);
HttpRequest = MockRepository.GenerateStub<HttpRequestBase>();
HttpContext = MockRepository.GenerateStub<HttpContextBase>();
HttpContext.Stub(x => x.Request).Return(HttpRequest);
HttpContext.User = _user;
_httpResponse = MockRepository.GenerateStub<HttpResponseBase>();
_httpResponse.Stub(x => x.Cookies).Return(new HttpCookieCollection());
HttpContext.Stub(x => x.Response).Return(_httpResponse);
Logger = MockRepository.GenerateStub<ILogger>();
WebAuthenticationService = MockRepository.GenerateStub<IWebAuthenticationService>();
MappingEngine = MockRepository.GenerateStub<IMappingEngine>();
AccountCreator = MockRepository.GenerateStub<IAccountCreator>();
AccountController = new AccountController(AccountService, Logger, WebAuthenticationService, MappingEngine, null, AccountCreator);
AccountController.ControllerContext = new ControllerContext(HttpContext, new RouteData(), AccountController);
}
/// <summary>
/// Initializes a new instance of the <see cref="EstatesController" /> class.
/// </summary>
/// <param name="unitsRepository">The units repository.</param>
/// <param name="imageService">The image service.</param>
/// <param name="accountService">The account service.</param>
/// <param name="unitFinder">The unit finder.</param>
public EstatesController(IRepository<Unit> unitsRepository, IImageService imageService, IAccountService accountService, IUnitFinderService unitFinder)
{
this.unitsRepository = unitsRepository;
this.imageService = imageService;
this.accountService = accountService;
this.unitFinder = unitFinder;
}
/// <summary>
/// Initializes a new instance of the <see cref="BasicAuthentication" /> class.
/// </summary>
/// <param name="userService">The user service.</param>
/// <param name="realm">The realm.</param>
/// <exception cref="System.ArgumentNullException">
/// userService
/// or
/// realm
/// </exception>
public BasicAuthentication(IAccountService userService, string realm)
{
if (userService == null) throw new ArgumentNullException("userService");
if (realm == null) throw new ArgumentNullException("realm");
_userService = userService;
_realm = realm;
}
public AccountController(IAccountService accountService)
{
repository = new AccountRepository();
if (accountService == null)
throw new ArgumentNullException();
this.accountService = accountService;
}
public CourseMenuPanel(IAccountService accountService, CourseModel courseModel)
:this()
{
_accountService = accountService;
_courseModel = courseModel;
_courseModel = courseModel;
}
public OrderRepository(IOrderService orderService, IAccountService accountService, IShippingMethodService shippingMethodService, ISessionStateService sessionStateService)
{
_orderService = orderService;
_accountService = accountService;
_shippingMethodService = shippingMethodService;
_sessionStateService = sessionStateService;
}
public TaskController(IAccountService accountService, ITaskService taskService, ITaskListService taskListService, ITagService tagService)
{
_accountService = accountService;
_taskService = taskService;
_taskListService = taskListService;
_tagService = tagService;
}
public void TestFixtureSetUp()
{
try
{
CodeSharp.Core.Configuration.ConfigWithEmbeddedXml(null
, "application_config"
, Assembly.GetExecutingAssembly()
, "Properties.Model.Test.ConfigFiles")
.RenderProperties()
.Castle(o => this.Resolve(o.Container));
Lock.InitAll(DependencyResolver.Resolve<ILockHelper>());
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
this._log = DependencyResolver.Resolve<ILoggerFactory>().Create(this.GetType());
this._sessionManager = DependencyResolver.Resolve<Castle.Facilities.NHibernateIntegration.ISessionManager>();
this._accountService = DependencyResolver.Resolve<IAccountService>();
this._appService = DependencyResolver.Resolve<IApplicationService>();
this._configService = DependencyResolver.Resolve<IConfigurationService>();
DependencyResolver.Resolve<ILockHelper>().Require<Account>();
}
public BatchDocumentCreatorViewModel(IAccountService accountService, ICacheService cacheService)
{
Accounts = new ObservableCollection<AccountRowViewModel>();
_accountService = accountService;
_cacheService = cacheService;
CreateDocuments = new CaptionCommand<string>(string.Format(Resources.Create_f, "").Trim(), OnCreateDocuments, CanCreateDocument);
}
public HomeControllerTests()
{
service = Substitute.For<IAccountService>();
controller = Substitute.ForPartsOf<HomeController>(service);
ReturnCurrentAccountId(controller, 1);
}
public PlayerManager(IDataService dataService, IAccountService accountService, IPlayerService playerService, IDialogService dialogservice, IResourceService resourceService)
{
this.m_dataService = dataService;
this.m_accountService = accountService;
this.PlayerService = playerService;
this.m_dialogService = dialogservice;
this.m_resourceService = resourceService;
Messenger.Default.Register<MediaOpenedMessage>(this, message =>
{
this.OnMediaOpened();
});
Messenger.Default.Register<MediaEndedMessage>(this, message =>
{
this.OnMediaEnded();
});
Messenger.Default.Register<MediaNextPressedMessage>(this, message =>
{
if (this.CanExecuteNextTrack())
{
this.ExecuteNextTrack();
}
});
Messenger.Default.Register<MediaPreviousPressedMessage>(this, message =>
{
if (this.CanExecutePreviousTrack())
{
this.ExecutePreviousTrack();
}
});
}
/// <summary>
/// Create a new instance of <see cref="CookieAuthentication" />.
/// </summary>
/// <param name="hashKey">Used to hash the ip address, recommended size is 64 bytes.</param>
/// <param name="accountService">Used to load users</param>
public CookieAuthentication(string hashKey, IAccountService accountService)
{
_accountService = accountService;
CookieName = "GriffinAuth";
AuthenticationScheme = "COOKIE";
HashKey = hashKey;
}
public BasePlaylistableViewModel(IDataService dataService, IAccountService accountService, IDialogService dialogService, IResourceService resourceService)
{
this.DataService = dataService;
this.AccountService = accountService;
this.DialogService = dialogService;
this.ResourceService = resourceService;
}
private void frmEmailCampaign_Load(object sender, EventArgs e)
{
try
{
string state = "ok";
_accessToken = OAuth.AuthenticateFromWinProgram(ref state);
if (string.IsNullOrEmpty(_accessToken))
{
Application.Exit();
}
//initialize ConstantContact members
IUserServiceContext userServiceContext = new UserServiceContext(_accessToken, _apiKey);
ConstantContactFactory _constantContactFactory = new ConstantContactFactory(userServiceContext);
_emailCampaignService = _constantContactFactory.CreateEmailCampaignService();
_emailCampaginScheduleService = _constantContactFactory.CreateCampaignScheduleService();
_listService = _constantContactFactory.CreateListService();
_accountService = _constantContactFactory.CreateAccountService();
}
catch (OAuth2Exception oauthEx)
{
MessageBox.Show(string.Format("Authentication failure: {0}", oauthEx.Message), "Warning");
}
PopulateCampaignTypeList();
PopulateListOfCountries();
PopulateUSAndCanadaListOfStates();
GetListOfContacts();
PopulateEmailLists();
}
public OrderRepository(IOrderService orderService, IAccountService accountService, IShippingMethodService shippingMethodService, ISuspensionManagerState suspensionManagerState)
{
_orderService = orderService;
_accountService = accountService;
_shippingMethodService = shippingMethodService;
_suspensionManagerState = suspensionManagerState;
}
public RegistrationTests()
{
this.factory = new RegistrationFactory();
this.accountService = new MockAccountService();
this.emailService = new MockEmailService();
this.accountServiceEmailAlreadyTaken = new MockAccountService(true);
}
/// <summary>
/// 默认构造函数
/// </summary>
/// <param name="accountService">帐号服务接口</param>
/// <param name="gloCache">全局缓存</param>
public AccountController(IAccountService accountService,
GlobalCache gloCache)
{
this.accountService = accountService;
this.gloCache = gloCache;
ViewBag.UserCount = gloCache.UserCount();
}
public DepositController(IUnitOfWork _unitOfWork, IDepositService _depositService, IAccountService _accountService, IMT4Service _mt4Service)
{
this.depositService = _depositService;
this.mt4Service = _mt4Service;
this.accountService = _accountService;
this.unitOfWork = _unitOfWork;
}
public ApiController(IAccountService accountService,
IClientManager clientManager, IEncryption encryption)
{
_accountService = accountService;
_clientManager = clientManager;
_encryption = encryption;
}
public AccountSelectorViewModel(IAccountService accountService, ICacheService cacheService, IApplicationState applicationState, IEntityService entityService,
IReportServiceClient reportServiceClient)
{
_accounts = new ObservableCollection<AccountScreenRow>();
_accountService = accountService;
_cacheService = cacheService;
_applicationState = applicationState;
_entityService = entityService;
_reportServiceClient = reportServiceClient;
ShowAccountDetailsCommand = new CaptionCommand<string>(Resources.AccountDetails.Replace(' ', '\r'), OnShowAccountDetails, CanShowAccountDetails);
PrintCommand = new CaptionCommand<string>(Resources.Print, OnPrint);
AccountButtonSelectedCommand = new CaptionCommand<AccountScreen>("", OnAccountScreenSelected);
AutomationCommandSelectedCommand = new CaptionCommand<AccountScreenAutmationCommandMap>("", OnAutomationCommandSelected);
EventServiceFactory.EventService.GetEvent<GenericEvent<EventAggregator>>().Subscribe(
x =>
{
if (x.Topic == EventTopicNames.ResetCache)
{
_accountButtons = null;
_batchDocumentButtons = null;
_selectedAccountScreen = null;
}
});
}
public void TestFixtureSetUp()
{
Configuration.ConfigWithEmbeddedXml(null, "application_config", Assembly.GetExecutingAssembly(), "Cooper.Sync.Test.ConfigFiles")
.RenderProperties()
.Castle(resolver => Resolve(resolver.Container));
//初始化同步锁
DependencyResolver.Resolve<ILockHelper>().Init<Account>();
DependencyResolver.Resolve<ILockHelper>().Init<GoogleConnection>();
_logger = DependencyResolver.Resolve<ILoggerFactory>().Create(GetType());
_sessionManager = DependencyResolver.Resolve<ISessionManager>();
_accountHelper = DependencyResolver.Resolve<IAccountHelper>();
_accountService = DependencyResolver.Resolve<IAccountService>();
_accountConnectionService = DependencyResolver.Resolve<IAccountConnectionService>();
_taskService = DependencyResolver.Resolve<ITaskService>();
_externalServiceProvider = DependencyResolver.Resolve<IExternalServiceProvider>();
_googleTokenService = DependencyResolver.Resolve<IGoogleTokenService>();
_syncProcessor = DependencyResolver.Resolve<IGoogleSyncProcesser>();
GoogleSyncSettings.ClientIdentifier = "234919028272-gsmmng06nheoih4ajp60oq8s33at1os0.apps.googleusercontent.com";
GoogleSyncSettings.ClientSecret = "jXcjxFzCQGferMI37I0GSc05";
}
public AccountBalances(IApplicationState applicationState,ICacheService cacheService, IAccountService accountService)
{
_applicationState = applicationState;
_cacheService = cacheService;
_accountService = accountService;
Balances = new Dictionary<int, decimal>();
}
/// <summary>
/// Ctor
/// </summary>
/// <param name="httpContext">HTTP context</param>
/// <param name="accountService">account service</param>
public FormsAuthenticationService(HttpContextBase httpContext,
IAccountService accountService)
{
this._httpContext = httpContext;
this._accountService = accountService;
this._expirationTimeSpan = FormsAuthentication.Timeout;
}
private IEnumerable<AccountSelectViewModel> GetAccountSelectors(AccountTransactionDocumentType documentType, Account selectedAccount, IAccountService accountService, ICacheService cacheService)
{
var accountMap = documentType.AccountTransactionDocumentAccountMaps.FirstOrDefault(x => x.AccountId == selectedAccount.Id);
return accountMap != null
? documentType.GetNeededAccountTypes().Select(x => new AccountSelectViewModel(accountService, cacheService.GetAccountTypeById(x), accountMap.MappedAccountId, accountMap.MappedAccountName))
: documentType.GetNeededAccountTypes().Select(x => new AccountSelectViewModel(accountService, cacheService.GetAccountTypeById(x)));
}
public AccountModule(IRegionManager regionManager,
IAutomationService automationService,
IUserService userService,
IAccountService accountService,
AccountSelectorView accountSelectorView, AccountSelectorViewModel accountSelectorViewModel,
AccountDetailsView accountDetailsView,
DocumentCreatorView documentCreatorView,
BatchDocumentCreatorView batchDocumentCreatorView, BatchDocumentCreatorViewModel batchDocumentCreatorViewModel)
: base(regionManager, AppScreens.AccountList)
{
_regionManager = regionManager;
_userService = userService;
_accountService = accountService;
_accountSelectorView = accountSelectorView;
_accountSelectorViewModel = accountSelectorViewModel;
_accountDetailsView = accountDetailsView;
_documentCreatorView = documentCreatorView;
_batchDocumentCreatorView = batchDocumentCreatorView;
_batchDocumentCreatorViewModel = batchDocumentCreatorViewModel;
AddDashboardCommand<EntityCollectionViewModelBase<AccountTypeViewModel, AccountType>>(Resources.AccountType.ToPlural(), Resources.Accounts, 40);
AddDashboardCommand<EntityCollectionViewModelBase<AccountViewModel, Account>>(Resources.Account.ToPlural(), Resources.Accounts, 40);
AddDashboardCommand<EntityCollectionViewModelBase<AccountScreenViewModel, AccountScreen>>(Resources.AccountScreen.ToPlural(), Resources.Accounts, 40);
AddDashboardCommand<EntityCollectionViewModelBase<AccountTransactionTypeViewModel, AccountTransactionType>>(Resources.TransactionType.ToPlural(), Resources.Accounts, 40);
AddDashboardCommand<EntityCollectionViewModelBase<AccountTransactionDocumentTypeViewModel, AccountTransactionDocumentType>>(Resources.DocumentType.ToPlural(), Resources.Accounts, 40);
AddDashboardCommand<EntityCollectionViewModelBase<AccountTransactionDocumentViewModel, AccountTransactionDocument>>(Resources.TransactionDocument.ToPlural(), Resources.Accounts, 40);
PermissionRegistry.RegisterPermission(PermissionNames.NavigateAccountView, PermissionCategories.Navigation, Resources.CanNavigateCash);
PermissionRegistry.RegisterPermission(PermissionNames.CreateAccount, PermissionCategories.Account, Resources.CanCreateAccount);
SetNavigationCommand(Resources.Accounts, Resources.Common, "Images/Xls.png", 70);
automationService.RegisterActionType(ActionNames.CreateAccountTransactionDocument, string.Format(Resources.Create_f, Resources.AccountTransactionDocument), new { AccountTransactionDocumentName = "" });
}
public RateController()
{
this._rateService = new RateService();
this._rateTypeService = new RateTypeService();
this._accountService = new AccountService();
this._placeService = new PlaceService();
}
public AccountRowViewModel(Account account, AccountTransactionDocumentType documentType, IAccountService accountService, ICacheService cacheService)
{
_account = account;
Amount = accountService.GetDefaultAmount(documentType, account);
Description = accountService.GetDescription(documentType, account);
TargetAccounts = GetAccountSelectors(documentType, account, accountService, cacheService).ToList();
}
public BaseController()
{
_accountService = DependencyResolver.Current.GetService<IAccountService>();
_dictionaryService = DependencyResolver.Current.GetService<IDictionaryService>();
CacheService = CacheProvider.Current.GetCache();
_adminData = DependencyResolver.Current.GetService<IAdminScheduleService>();
}
public ProfilePresenter()
{
_redirector = ObjectFactory.GetInstance<IRedirector>();
_userSession = ObjectFactory.GetInstance<IUserSession>();
if (!_userSession.LoggedIn || _userSession.CurrentUser == null)
_redirector.GoToAccountLoginPage();
_alertService = ObjectFactory.GetInstance<IAlertService>();
_webContext = ObjectFactory.GetInstance<IWebContext>();
_accountService = ObjectFactory.GetInstance<IAccountService>();
_privacyService = ObjectFactory.GetInstance<IPrivacyService>();
_account = _userSession.CurrentUser;
if (_webContext.AccountID > 0 && _webContext.AccountID != _userSession.CurrentUser.AccountID)
{
_accountBeingViewed = _accountService.GetAccountByID(_webContext.AccountID);
_accountBeingViewed.Profile = Profile.GetProfileByAccountID(_webContext.AccountID);
}
else
{
_accountBeingViewed = _userSession.CurrentUser;
_accountBeingViewed.Profile = Profile.GetProfileByAccountID(_userSession.CurrentUser.AccountID);
}
if (_accountBeingViewed == null)
_redirector.GoToAccountLoginPage();
if (_accountBeingViewed.Profile != null && _accountBeingViewed.Profile.ProfileID > 0)
_privacyFlags = PrivacyFlag.GetPrivacyFlagsByProfileID(_accountBeingViewed.Profile.ProfileID);
else
_redirector.GoToHomePage();
}
public HomePresenter()
{
_userSession = new UserSession();
_accountService=new AccountService();
_redirector = new Redirector();
_profileService = new ProfileService();
}
public ActionResult Index(LoginViewModel model)
{
string error = null;
IAccountService accountService = null;
Account account = null;
if (model.UserName.IsNullOrEmpty() || model.Password.IsNullOrEmpty())
{
error = "提交参数不完整";
}
else
{
if (ModelState.IsValid)
{
accountService = StructureMap.ObjectFactory.GetInstance <IAccountService>();
account = accountService.GetAccount(model.UserName);
if ((int)Session["LoginTriedTime"] >= SiteConfig.TryUserLoginTimes)
{
string code = (string)TempData["VerificationCode"] as string;
if (model.VerificationCode.IsNullOrEmpty())
{
error = "请输入验证码";
}
else if (!model.VerificationCode.Equals(code, StringComparison.OrdinalIgnoreCase))
{
error = "验证码不正确";
}
}
else if (account == null)
{
error = "用户名不存在";
}
else if (accountService.TryLogin(model.UserName, model.Password, true, true) == null)
{
error = "密码错误";
}
}
}
if (!error.IsNullOrEmpty() || !ModelState.IsValid)
{
var tryLoginTimes = 0;
if (Session["LoginTriedTime"] != null)
{
tryLoginTimes = (int)Session["LoginTriedTime"];
}
model.ShowVerificationCode = tryLoginTimes >= SiteConfig.TryUserLoginTimes;
Session["LoginTriedTime"] = tryLoginTimes + 1;
model.MessagerList = new List <Messager>();
model.MessagerList.Add(new Messager(MessageLevel.Error, error));
return(View(model));
}
Session["LoginTriedTime"] = 0;//清空登录次数
Logger.Account.InfoFormat("User login succeed：{0}", model.UserName);
if (model.ReturnUrl.IsNullOrEmpty())
{
return(RedirectToAction("Index", "Calendar"));
}
else
{
return(Redirect(model.ReturnUrl.UrlDecode()));
}
}
public AccountController(IAccountService accountService) => _accountService = accountService;
public TokenController(IAccountService accountService, IConfiguration configuration)
{
_accountService = accountService;
authenticationHelper = new AuthenticationHelper(configuration);
}
public UpdateCommand(IConsole console, ILogger <UpdateCommand> logger,
IProjectMemberService projectMemberService, IProjectService projectService, IAccountService accountService) : base(console, logger)
{
_projectMemberService = projectMemberService;
_projectService = projectService;
_accountService = accountService;
}
public ValidComb UpdateObject(ValidComb validComb, IAccountService _accountService, IClosingService _closingService)
{
return(_validator.ValidUpdateObject(validComb, _accountService, _closingService) ? _repository.UpdateObject(validComb) : validComb);
}
public ValidComb CreateObject(ValidComb validComb, IAccountService _accountService, IClosingService _closingService)
{
validComb.Errors = new Dictionary <String, String>();
return(_validator.ValidCreateObject(validComb, _accountService, _closingService) ? _repository.CreateObject(validComb) : validComb);
}
public AccountController(IAccountService accountService, IMapper mapper)
{
_accountService = accountService;
_mapper = mapper;
}
public AccountController(IAccountService accountService)
{
this.accountService = accountService;
}
public ApiBankAccountController(IRestApiHelper restApiHelper, IHttpContextAccessor httpContextAccessor, IPersonService personService, IApiBankAccountService apiBankAccountService, IAccountService accountService)
{
this.restApiHelper = restApiHelper;
this.personService = personService;
this.apiBankAccountService = apiBankAccountService;
this.httpContextAccessor = httpContextAccessor;
this.accountService = accountService;
}
public MenuService(IMenuRepository menuRepository, IMenuPermissionRepository menuPermissionRepository, IMapper mapper, IRoleMenuRepository roleMenuRepository, IButtonRepository buttonRepository, IRoleMenuButtonRepository roleMenuButtonRepository, IAccountRoleRepository accountRoleRepository, IAccountService accountService, IButtonPermissionRepository buttonPermissionRepository, ILogger <MenuService> logger, AdminDbContext dbContext, ISystemService systemService, SystemConfigModel systemConfig)
{
_menuRepository = menuRepository;
_menuPermissionRepository = menuPermissionRepository;
_mapper = mapper;
_roleMenuRepository = roleMenuRepository;
_buttonRepository = buttonRepository;
_roleMenuButtonRepository = roleMenuButtonRepository;
_accountRoleRepository = accountRoleRepository;
_accountService = accountService;
_buttonPermissionRepository = buttonPermissionRepository;
_logger = logger;
_dbContext = dbContext;
_systemService = systemService;
_systemConfig = systemConfig;
}
public TransferEtherFromAccountPrivateKeyCommand(IAccountService accountService) : base(accountService)
{
Name = "account-transfer-from-account-private-key";
Description = "Transfers ether using the account's private key";
}
public AccountProxy(IAccountService cuentaReal)
{
this._cuentaReal = cuentaReal;
}
public ProductService(ChushkaDbContext dbContext, IAccountService accountService)
{
this.dbContext = dbContext;
this.accountService = accountService;
}
public SqLiteService(IWebHostEnvironment webHostEnvironment,
IAccountService accountService)
{
_webHostEnvironment = webHostEnvironment;
_accountService = accountService;
}
public BankingController(IAccountService accountService)
{
_accountService = accountService;
}
public AuthenticationService(IAccountService dataService, IPasswordHasher passwordHasher)
{
_dataService = dataService;
_passwordHasher = passwordHasher;
}
public UserController(IAccountService accountService, IUserService userService, IRelationshipService relationshipService)
{
this.accountService = accountService;
this.userService = userService;
this.relationshipService = relationshipService;
}
public PatientUsersController(IPatientUserService patientService, IAccountService accountService)
{
_patientUserService = patientService;
_accountService = accountService;
}
public AccountController(IUserRepository userRepository, IUserRoleRepository userRoleRepository, IAccountService accountService)
{
_userRepository = userRepository;
_userRoleRepository = userRoleRepository;
_accountService = accountService;
}
public InvestService(ICryptoPriceService cryptoPriceService, IAccountService accountService)
{
_cryptoPriceService = cryptoPriceService;
_accountService = accountService;
}
public AccountController(IAccountService accountService)
{
_accountSerivce = accountService;
}
/// <summary>
/// Initializes a new instance of the <see cref="DigestAuthenticator"/> class.
/// </summary>
/// <param name="realmRepository">Used to lookup the realm for a HTTP request</param>
/// <param name="userService">Supplies users during authentication process.</param>
public DigestAuthenticator(IRealmRepository realmRepository, IAccountService userService)
{
_realmRepository = realmRepository;
_userService = userService;
}
public SecurityController(IAccountService accountService, IUserService userService) : base(accountService, userService)
{
}
public AccountController(IRepository <User> userRepository, ILogger logger, IMailer mailer, IOptions <WebsiteConfiguration> websiteConfig, IDataSetsHelper dataSetsHelper, IRoles roles, IAccountService accountService, IAuthentication authentication, IFileSourceHelper fileSourceHelper, IFacebookService facebookService, IOptions <RecaptchaConfiguration> recaptchaConfig)
: base(logger, dataSetsHelper, roles, authentication, fileSourceHelper)
{
_userRepository = userRepository;
_logger = logger;
_accountService = accountService;
_authentication = authentication;
_facebookService = facebookService;
_recaptchaConfig = recaptchaConfig.Value;
}
public DetailsModel(IAccountService context)
{
_context = context;
}
public JournalRepository(EFDBContext context, IAccountService accountService)
{
this.context = context;//new EFDBContext();
this.accountService = accountService;
}
public ListCommand(IConsole console, ILogger <ListCommand> logger, IAccountService accountService) : base(console, logger)
{
_accountService = accountService;
}
public LitmusTestProcessor(CronJobDb cronJob, JobService jobService, string litmusTestCacheName)
: base(cronJob, jobService, litmusTestCacheName)
{
campaignService = IoC.Container.GetInstance <ICampaignService>();
accountService = IoC.Container.GetInstance <IAccountService>();
}
public RoleService(IMapper mapper, IRoleRepository repository, IRoleMenuRepository roleMenuRepository, IAccountRoleRepository accountRoleRepository, IAccountService accountService, IMenuRepository menuRepository, AdminDbContext dbContext, ICacheHandler cacheHandler, IRolePageRepository pageRepository, IRoleButtonRepository buttonRepository1, IRolePermissionRepository permissionRepository)
{
_mapper = mapper;
_repository = repository;
_roleMenuRepository = roleMenuRepository;
_accountRoleRepository = accountRoleRepository;
_accountService = accountService;
_menuRepository = menuRepository;
_dbContext = dbContext;
_cacheHandler = cacheHandler;
_pageRepository = pageRepository;
_buttonRepository = buttonRepository1;
_permissionRepository = permissionRepository;
}
public AccountController(IAccountService service)
{
this.service = service;
}
