public PublishService(ILogRepository logRepository, IContentRepository contentRepository, IContextRepository contextRepository, IPublishRepository publishRepository)
 {
     _logRepository     = logRepository;
     _contentRepository = contentRepository;
     _contextRepository = contextRepository;
     _publishRepository = publishRepository;
 }
 public AccountController(UserManager <IdentityUser> userManager, SignInManager <IdentityUser> signInManager, IContextRepository context, IConfiguration configuration)
 {
     this.userManager   = userManager;
     this.signInManager = signInManager;
     this.context       = context;
     this.configuration = configuration;
 }
Beispiel #3
0
 /// <summary>
 /// Performs constructor injection for repository interfaces used in this service.
 /// </summary>
 /// <param name="userManager"></param>
 /// <param name="signInManager"></param>
 /// <param name="tokenManagement"></param>
 /// <param name="httpClient"></param>
 /// <param name="contextRepository"></param>
 /// <param name="userRepository"></param>
 /// <param name="httpContextAccessor"></param>
 /// <param name="milvaMailSender"></param>
 /// <param name="sharedLocalizer"></param>
 /// <param name="milvaLogger"></param>
 /// <param name="redisCacheService"></param>
 public AccountService(UserManager <AppUser> userManager,
                       SignInManager <AppUser> signInManager,
                       ITokenManagement tokenManagement,
                       HttpClient httpClient,
                       IContextRepository <EducationAppDbContext> contextRepository,
                       IBaseRepository <AppUser, Guid, EducationAppDbContext> userRepository,
                       IHttpContextAccessor httpContextAccessor,
                       IMilvaMailSender milvaMailSender,
                       IStringLocalizer <SharedResource> sharedLocalizer,
                       IMilvaLogger milvaLogger,
                       IRedisCacheService redisCacheService) : base(userManager, signInManager, tokenManagement, contextRepository, sharedLocalizer, httpContextAccessor, true)
 {
     _userName            = httpContextAccessor.HttpContext.User.Identity.Name;
     _redisCacheService   = redisCacheService;
     _milvaLogger         = milvaLogger;
     _milvaMailSender     = milvaMailSender;
     _userRepository      = userRepository;
     _userManager         = userManager;
     _signInManager       = signInManager;
     _httpClient          = httpClient;
     _contextRepository   = contextRepository;
     _httpContextAccessor = httpContextAccessor;
     _localizer           = sharedLocalizer;
     _tokenManagement     = tokenManagement;
     _loginProvider       = tokenManagement.LoginProvider;
     _tokenName           = tokenManagement.TokenName;
 }
 public HackService(IContextRepository contextRepository,
                    ILogRepository logRepository, IRenderingRepository renderingRepository)
 {
     _contextRepository   = contextRepository;
     _logRepository       = logRepository;
     _renderingRepository = renderingRepository;
 }
 public static bool Delete(IContextRepository repository,
                           IMapper mapper,
                           FilterLambdaOperatorParameters filterExpression)
 => repository.DeleteAsync <TModel, TData>
 (
     GetFilter(mapper.MapToOperator(filterExpression))
 ).Result;
Beispiel #6
0
 public HeroService(IRenderingRepository renderingRepository, IContentRepository contentRepository,
                    IContextRepository contextRepository)
 {
     _renderingRepository = renderingRepository;
     _contentRepository   = contentRepository;
     _contextRepository   = contextRepository;
 }
 public GetTicketService(
     IContextRepository <ITicketContext> repository,
     IMapper mapper)
 {
     _repository = repository;
     _mapper     = mapper;
 }
 public LookupTicketService(
     IContextRepository <ITicketContext> repository,
     IMapper mapper)
     : base(GetDefaultSpecification())
 {
     _repository = repository;
     _mapper     = mapper;
 }
Beispiel #9
0
 public GitHubApiBusiness(IContextRepository context, IGitHubApi gitHubApi, IMapperGitHubRepository mapperGitHubRepository, IMapperRepository mapperRepository, IMapperFavorite mapperFavorite)
 {
     _context                = context;
     _gitHubApi              = gitHubApi;
     _mapperRepository       = mapperRepository;
     _mapperGitHubRepository = mapperGitHubRepository;
     _mapperFavorite         = mapperFavorite;
 }
 public SearchContextManager(IContextRepository contextRepository, IContentRepository contentRepository, ISearchService searchService,
                             IConverter <IBlog, BlogViewModel> blogViewModelConverter)
 {
     _contextRepository      = contextRepository;
     _contentRepository      = contentRepository;
     _searchService          = searchService;
     _blogViewModelConverter = blogViewModelConverter;
 }
Beispiel #11
0
 public CatalogController(IContextRepository <Product> product,
                          IContextRepository <Catalog> catalog,
                          IContextRepository <ProductsCatalogs> productscatalogs)
 {
     this._product          = product;
     this._catalog          = catalog;
     this._productscatalogs = productscatalogs;
 }
 public void InitCtx(IContextRepository <DbContext> repository, DbContext db)
 {
     if (repository == null)
     {
         throw new InvalidCastException("No db Context used");
     }
     repository.SetContext(db);
 }
Beispiel #13
0
 public static TModelReturn Query(IContextRepository repository,
                                  IMapper mapper,
                                  IExpressionParameter queryExpression,
                                  SelectExpandDefinitionParameters expansion = null)
 => repository.QueryAsync <TModel, TData, TModelReturn, TDataReturn>
 (
     GetQueryFunc(mapper.MapToOperator(queryExpression)),
     mapper.MapExpansion(expansion)
 ).Result;
Beispiel #14
0
 private static Task <IEnumerable <dynamic> > Query <TModel, TData>(IContextRepository repository,
                                                                    IExpressionPart queryExpression)
     where TModel : BaseModel
     where TData : BaseData
 => repository.QueryAsync <TModel, TData, IEnumerable <dynamic>, IEnumerable <dynamic> >
 (
     (Expression <Func <IQueryable <TModel>, IEnumerable <dynamic> > >)queryExpression.Build(),
     (SelectExpandDefinition)null
 );
 public UnlinkTicketService(
     IContextRepository <ITicketContext> repository,
     INotificationService notificationService,
     IWorkflowService workflowService)
 {
     _repository          = repository;
     _notificationService = notificationService;
     _workflowService     = workflowService;
 }
Beispiel #16
0
 public static ICollection <TModel> GetItems(IContextRepository repository,
                                             IMapper mapper,
                                             IExpressionParameter filterExpression      = null,
                                             IExpressionParameter queryFunc             = null,
                                             SelectExpandDefinitionParameters expansion = null)
 => repository.GetAsync <TModel, TData>
 (
     GetFilter(mapper.MapToOperator(filterExpression)),
     GetQueryFunc(mapper.MapToOperator(queryFunc)),
     mapper.MapExpansion(expansion)
 ).Result;
 public DeleteTicketService(
     IContextRepository <ITicketContext> repository,
     INotificationService notificationService,
     IWorkflowService workflowService,
     IDeleteTicketResultFactory factory)
 {
     _repository          = repository;
     _notificationService = notificationService;
     _workflowService     = workflowService;
     _factory             = factory;
 }
Beispiel #18
0
        public PacketInspectorViewModel(IContextRepository ctxtRepository)
        {
            _ctxtRepository = ctxtRepository;
            _context        = ctxtRepository.NewContext();

            _packetItems = new ExtendedObservableCollection <PacketOverviewViewModel>();
            PacketView   = new ReadOnlyObservableCollectionView <PacketOverviewViewModel, int>(_packetItems, true);

            _context.Packets.CollectionChanged += Packets_CollectionChanged;

            DebugCommand = new RelayCommand(InsertPacket);
        }
Beispiel #19
0
        //Singleton模式
        public BaseService(IContextRepository contextRepository)
        {
            this.contextRepository = contextRepository;
            this.repository        = Repository <T> .Instance;
            this.collection        = repository.GetCollection();

            if (this.GetContext() != null && this.GetContext().IsUseCache)
            {
                cache = LocalCache <T> .Instance;
                RebuildCache();
            }
        }
 private async static Task <TModel> QueryEntity <TModel, TData>(IContextRepository repository,
                                                                IExpressionPart filterExpression, SelectExpandDefinition selectExpandDefinition = null)
     where TModel : BaseModel
     where TData : BaseData
 => (
     await repository.GetAsync <TModel, TData>
     (
         (Expression <Func <TModel, bool> >)filterExpression.Build(),
         null,
         selectExpandDefinition
     )
     ).FirstOrDefault();
Beispiel #21
0
 public static TModel Get(IContextRepository repository,
                          IMapper mapper,
                          IExpressionParameter filterExpression,
                          IExpressionParameter queryFunc             = null,
                          SelectExpandDefinitionParameters expansion = null)
 => GetItems
 (
     repository,
     mapper,
     filterExpression,
     queryFunc,
     expansion
 ).SingleOrDefault();
Beispiel #22
0
 public UpdateTicketService(
     IContextRepository <ITicketContext> repository,
     IMapper mapper,
     INotificationService notificationService,
     IWorkflowService workflowService,
     IUpdateTicketResultFactory factory,
     IValidator <UpdateTicketDto> validator)
 {
     _repository          = repository;
     _mapper              = mapper;
     _notificationService = notificationService;
     _workflowService     = workflowService;
     _factory             = factory;
     _validator           = validator;
 }
Beispiel #23
0
        //Singleton模式
        public BaseService(IContextRepository contextRepository)
        {
            this.contextRepository = contextRepository;
            this.repository        = Repository <T> .Instance;
            this.collection        = repository.GetCollection(DatabaseManager.Instance.GetDbName(typeof(T)));

            if (this.GetContext().IsUseCache)
            {
                cache = LocalCache <T> .Instance;
                RebuildCache();
            }

            if (_historyService == null)
            {
                _historyService = new HistoryService();
            }
        }
 /// <summary>
 /// Performs constructor injection for repository interfaces used in this service.
 /// </summary>
 /// <param name="userManager"></param>
 /// <param name="signInManager"></param>
 /// <param name="tokenManagement"></param>
 /// <param name="contextRepository"></param>
 /// <param name="localizer"></param>
 /// <param name="httpContextAccessor"></param>
 /// <param name="useWhiteList"></param>
 public IdentityOperations(TUserManager userManager,
                           SignInManager <TUser> signInManager,
                           ITokenManagement tokenManagement,
                           IContextRepository <TDbContext> contextRepository,
                           TLocalizer localizer,
                           IHttpContextAccessor httpContextAccessor,
                           bool useWhiteList)
 {
     _userManager       = userManager;
     _signInManager     = signInManager;
     _tokenManagement   = tokenManagement;
     _localizer         = localizer;
     _contextRepository = contextRepository;
     _userName          = httpContextAccessor.HttpContext.User.Identity.Name;
     _useWhiteList      = useWhiteList;
     _loginProvier      = tokenManagement.LoginProvider;
     _tokenName         = tokenManagement.TokenName;
 }
        public static async Task <IEnumerable <dynamic> > GetDynamicSelect <TModel, TData>(this DataRequest request, IContextRepository contextRepository, IMapper mapper)
            where TModel : BaseModelClass
            where TData : BaseDataClass
        {
            Expression <Func <IQueryable <TModel>, IEnumerable <dynamic> > > exp = Expression.Parameter(typeof(IQueryable <TModel>), "q").BuildLambdaExpression <IQueryable <TModel>, IEnumerable <dynamic> >
                                                                                   (
                p => request.Distinct == true
                    ? request.Options.CreateDataSourceRequest()
                .CreateUngroupedMethodExpression(p.GetSelectNew <TModel>(request.Selects))
                .GetDistinct()
                    : request.Options.CreateDataSourceRequest()
                .CreateUngroupedMethodExpression(p.GetSelectNew <TModel>(request.Selects))
                                                                                   );

            return(await contextRepository.QueryAsync <TModel, TData, IEnumerable <dynamic>, IEnumerable <dynamic> >
                   (
                       exp,
                       mapper.MapExpansion(request.SelectExpandDefinition)
                   ));
        }
 public static async Task <DataSourceResult> GetData <TModel, TData>(this DataRequest request, IContextRepository contextRepository, IMapper mapper)
     where TModel : BaseModelClass
     where TData : BaseDataClass
 {
     return(await request.Options.CreateDataSourceRequest().GetDataSourceResult <TModel, TData>
            (
                contextRepository,
                mapper.MapExpansion(request.SelectExpandDefinition),
                request.Includes.BuildIncludesExpressionCollection <TModel>()
            ));
 }
 public WorklogRepository(IContextRepository contextRepository, IUserRepository userRepository)
 {
     _contextRepository = contextRepository;
     _userRepository = userRepository;
 }
 public static async Task <bool> Delete <TModel, TData>(this DataRequest request, IContextRepository contextRepository)
     where TModel : BaseModelClass
     where TData : BaseDataClass
 => await contextRepository.DeleteAsync <TModel, TData>(ExpressionBuilder.Expression <TModel>(request.Options.CreateDataSourceRequest().Filters));
 public WorkflowStepRepository(IContextRepository contextRepository)
 {
     _contextRepository = contextRepository;
 }
        public static async Task <BaseModelClass> GetSingleOrDefault <TModel, TData>(this DataRequest request, IContextRepository contextRepository, IMapper mapper)
            where TModel : BaseModelClass
            where TData : BaseDataClass
        {
            Expression <Func <IQueryable <TModel>, IQueryable <TModel> > > exp = request.Options.CreateDataSourceRequest().CreateUngroupedQueryableExpression <TModel>();

            return
                ((
                     await contextRepository.QueryAsync <TModel, TData, IQueryable <TModel>, IQueryable <TData> >
                     (
                         exp,
                         mapper.MapExpansion(request.SelectExpandDefinition)
                     )
                     ).SingleOrDefault());
        }
Beispiel #31
0
 public TeamRepository(IContextRepository contextRepository)
 {
     _contextRepository = contextRepository;
 }
 public static async Task <bool> Save <TModel, TData>(TModel item, IContextRepository contextRepository)
     where TModel : BaseModelClass
     where TData : BaseDataClass
 => await contextRepository.SaveGraphAsync <TModel, TData>(item);
Beispiel #33
0
 public UserRepository(IContextRepository contextRepository)
 {
     _contextRepository = contextRepository;
 }
 public static Task <bool> InvokeGenericSaveMethod(this PostModelRequest request, string methodName, BaseModelClass item, IContextRepository contextRepository)
 => (Task <bool>)request
 .GetGenericMethod(methodName)
 .Invoke(null, new object[] { item, contextRepository });
Beispiel #35
0
 public TaskRepository(IContextRepository contextRepository, IUserRepository userRepository)
 {
     _contextRepository = contextRepository;
     _userRepository = userRepository;
 }