public SalesController(IClientRepository clientRepository, ISaleRepository saleRepository,
     ILotteryRepository lotteryRepository)
 {
     _clientRepository = clientRepository;
     _saleRepository = saleRepository;
     _lotteryRepository = lotteryRepository;
 }
Example #2
0
		public ClientExcelHelper(
			IClientRepository clients,
			IExcelClientCalculation excel)
		{
			_clients = clients;
			_excel = excel;
		}
Example #3
0
        static Program()
        {
            IoC.RegisterAll();

            ClientRepository = IoC.Resolve<IClientRepository>();
            OrderRepository = IoC.Resolve<IOrderRepository>();
        }
        public ExternalModule(ICustomerRepository customers, IClientRepository clients)
        {
            Get["/CustomerClient/{id}"] = param =>
            {
                Guid paramId;
                Guid.TryParse(param.id, out paramId);
                var searchId = paramId;

                this.Info(() => "Searching for Customer | Client {0}".FormatWith(searchId));

                var customerAcc = customers.FirstOrDefault(x => x.Id == searchId);
                var clientAcc = clients.FirstOrDefault(x => x.Id == searchId);

                var accountNumber = "DEFAULT";
                if (customerAcc != null)
                {
                    accountNumber = customerAcc.CustomerAccountNumber.ToString();
                    this.Info(() => "Found Customer {0}".FormatWith(searchId));
                }
                if (clientAcc != null)
                {
                    accountNumber = clientAcc.ClientAccountNumber.ToString();
                    this.Info(() => "Found Client {0}".FormatWith(searchId));
                }

                if (accountNumber.Equals("DEFAULT"))
                    throw new LightstoneAutoException("Customer | Client could not be found: {0}".FormatWith(searchId));

                return accountNumber;
            };

           
        }
 public ClientTask(
     IClientRepository clientRepository,
     IClientAuthorizationRepository clientAuthorizationRepository)
 {
     ClientRepository = clientRepository;
     ClientAuthorizationRepository = clientAuthorizationRepository;
 }
Example #6
0
		public AuthenticationController(
			IClientRepository clients,
			IAuthenticationService authentication)
		{
			_clients = clients;
			_authentication = authentication;
		}
 public AuthorizationServerHost(ICryptoKeyStore cryptoKeyStore, INonceStore nonceStore, IClientRepository clientRepository, IUserRepository userRepository)
 {
     _cryptoKeyStore = cryptoKeyStore;
     _nonceStore = nonceStore;
     _clientRepository = clientRepository;
     _userRepository = userRepository;
 }
Example #8
0
        static void AutalizarCliente(IClientRepository clientRepository, int id)
        {
            var client = clientRepository.GetById(id);
            client.Name = "Atualizado";

            clientRepository.Update(client);
        }
 public ClientServices(IRepository repository, IClientRepository clientRepository, IAccountRepository accountRepository, IHelper helper)
 {
     _repository = repository;
     _clientRepository = clientRepository;
     _accountRepository = accountRepository;
     _helper = helper;
 }
Example #10
0
		public ClientPermissions(
			IIdentityService identity,
			IClientRepository clients)
		{
			_identity = identity;
			_clients = clients;
		}
 public ClientPresenter(IClientView view, ClientModel model)
 {
     _view = view;
     _model = model;
     _clientRepository = _model.ClientRepository;
     _orderRepository = _model.OrderRepository;
 }
        public IntegrationModule(ICustomerRepository customers, IClientRepository clients)
        {
            Get["/Integration/ClientCustomerContracts/All"] = param =>
            {
                var result = new List<IntegrationClientDto>();
                var clientContracts = clients.ToList().Select(
                    s =>
                        new IntegrationClientDto(s.Id, s.Name, s.ClientAccountNumber.ToString(), s.IsActive,
                            s.Contracts
                                .Select(c => new IntegrationContractDto(c.Id, c.Name, c.Packages
                                    .Select(p => new PackageDto() {PackageId = p.PackageId, Name = p.Name, IsActive = p.IsActive}))))).ToList();

                result.AddRange(clientContracts.Where(w => w.Contracts.Any()));

                var customerContracts = customers.ToList().Select(
                    s =>
                        new IntegrationClientDto(s.Id, s.Name, s.CustomerAccountNumber.ToString(), s.IsActive,
                            s.Contracts.Select(c => new IntegrationContractDto(c.Id, c.Name, c.Packages
                                .Select(p => new PackageDto() { Id = p.Id, PackageId = p.PackageId, Name = p.Name, IsActive = p.IsActive}))))).ToList();

                result.AddRange(customerContracts.Where(w => w.Contracts.Any()));

                return Response.AsJson(result);
            };
        }
Example #13
0
 public EventLogic(IEventRepository eventRepository, IClientRepository clientRepository, IClientLogic clientLogic, ILog log)
 {
     _eventRepository = eventRepository;
     _clientRepository = clientRepository;
     _clientLogic = clientLogic;
     _log = log;
 }
 public OrderPresenter(OrderModel model, IOrderView view)
 {
     _model = model;
     _view = view;
     _produtRepository = _model.ProductRepository;
     _clientRepository = _model.ClientRepository;
     ClientsList = new BindingList<Client>(_clientRepository.GetAll().Where(x => x.IsActive == true).ToList());
 }
 public OrderListPresenter(IOrderListView view, OrderListModel model)
 {
     _view = view;
     _model = model;
     _orderRepository = _model.OrderRepository;
     _clientRepository = _model.ClientRepository;
     ClientsList = new BindingList<Client>(_clientRepository.GetAll().ToList());
 }
Example #16
0
 public ProjectVM()
 {
     this.clientRepo = new ClientRepository(new DAL.CompanyContext());
     this.projectRepo = new ProjectRepository(new DAL.CompanyContext());
     this.Clients = clientRepo.GetClients().ToList();
     this.Project = new Project();
     this.Project.Client = new Client();
 }
        protected override void Context()
        {
            _handler = Resolve<ClientHandlers>();
            _clientRepository = Resolve<IClientRepository>();
            _tenantContext = Resolve<ITenantContext>();

            _tenantContext.SetTenantId(_tenant);
        }
		public KeyManagementService(IClientRepository clientRepository, ILicenseKeyService licenseKeyService,
			IActivationLogService activationLogService, IHashingProvider hashingProvider, IServiceProductsRepository serviceProductsRepository)
		{
			_clientRepository = clientRepository;
			_licenseKeyService = licenseKeyService;
			_activationLogService = activationLogService;
			_hashingProvider = hashingProvider;
			_serviceProductsRepository = serviceProductsRepository;
		}
 public ClientController(
     IBus bus,
     IClientRepository clientRepository,
     IEmployeeService employeeService)
 {
     _bus = bus;
     _clientRepository = clientRepository;
     _employeeService = employeeService;
 }
Example #20
0
		public ExcelClientCalculation(
			ICalculationRepository calculations,
			IClientBalanceRepository balance,
			IClientRepository clients)
		{
			_balance = balance;
			_calculations = calculations;
			_clients = clients;
		}
        public ClientModule(IClientRepository clientRepository)
            :base("/read/clients")
        {
            this.RequiresAuthentication();

            Get["/"] = _ => Json(clientRepository.ToList());

            Get["/{id:guid}"] = parameters => Json(clientRepository.GetById((Guid)parameters.id));
        }
 public SMSGatewayController(IMessageValidation messageValidation, IAuditLogRepository auditLogRepository, IResolveMessageService resolveMessageService, IDocSMSRepository docSmsRepository, ISmsQueryResolverService smsQueryResolver, IClientRepository clientRepository)
 {
     _messageValidation = messageValidation;
     _auditLogRepository = auditLogRepository;
     _resolveMessageService = resolveMessageService;
     _docSMSRepository = docSmsRepository;
     _smsQueryResolver = smsQueryResolver;
     _clientRepository = clientRepository;
 }
        protected override void Context()
        {
            _handler = Resolve<ClientHandlers>();
            _clientRepository = Resolve<IClientRepository>();
            _tenantContext = Resolve<ITenantContext>();

            _tenantContext.SetTenantId(_tenant);
            _handler.AsDynamic().Handle(new ClientCreated(_id, "John Doe BVBA", DateTime.UtcNow) { Version = 1 });
        }
 public ClientAuthorizationTask(
     IClientRepository clientRepository,
     IClientAuthorizationRepository clientAuthorizationRepository,
     IUserInfoRepository userInfoRepository)
 {
     ClientRepository = clientRepository;
     ClientAuthorizationRepository = clientAuthorizationRepository;
     UserInfoRepository = userInfoRepository;
 }
Example #25
0
		public BalanceController(
			IClientRepository clients,
			IClientBalance balance,
			IClientBalanceRepository balanceRepository)
		{
			_clients = clients;
			_balance = balance;
			_balanceRepository = balanceRepository;
		}
Example #26
0
 public OrderLogic(IRepository<Order> repository, IStatusLogic statusLogic, IOrderItemLogic orderItemLogic,
     IClientRepository clientRepository, IOrderItemRepository orderItemRepository, IGoodLogic goodLogic)
 {
     _repository = repository;
     _statusLogic = statusLogic;
     _orderItemLogic = orderItemLogic;
     _clientRepository = clientRepository;
     _orderItemRepository = orderItemRepository;
     _goodLogic = goodLogic;
 }
Example #27
0
 public MessageHandlerFactory(IClientRepository clientRepository, IClientIDGenerator clientIDGenerator, IClientFactory clientFactory, IClientWorkflowManager clientWorkflowManager)
 {
     this.metaConnectHandler = new MetaConnectHandler(clientRepository);
     this.metaDisconnectHandler = new MetaDisconnectHandler(clientRepository);
     this.metaHandshakeHandler = new MetaHandshakeHandler(clientIDGenerator, clientFactory, clientWorkflowManager);
     this.metaSubscribeHandler = new MetaSubscribeHandler(clientRepository);
     this.metaUnsubscribeHandler = new MetaUnsubscribeHandler(clientRepository);
     this.swallowHandler = new SwallowHandler();
     this.forwardingHandler = new ForwardingHandler(clientRepository);
 }
		public void TestInitialize()
		{
			_fixture = new Fixture();
			_context = new CompositionHelper(Settings.Default.MainConnectionString, Settings.Default.FilesConnectionString);
			_context.Kernel.Bind<ApplicationController>().ToSelf();

			_controller = _context.Kernel.Get<ApplicationController>();
			_clientRepository = _context.Kernel.Get<IClientRepository>();
			_applicationRepository = _context.Kernel.Get<IApplicationRepository>();
		}
Example #29
0
        public ClientLogic(IClientRepository repository)
        {
            _repository = repository;

            Mapper.Initialize(cfg =>
            {
                cfg.CreateMap<ClientAddressPoco, ClientAddressDto>();
                cfg.CreateMap<ClientPoco, ClientDto>();
            });
        }
Example #30
0
        static void CriarCliente(IClientRepository clientRepository)
        {
            var cliente = new Client
            {
                Name = "Teste 1",
                Jobs = new List<Job> { new Job { Name = "Job do Cliente 1" } }
            };

            clientRepository.Create(cliente);
        }
 public GetManyRequestHandler(IClientRepository clientRepository)
 {
     fClientRepository = clientRepository;
 }
Example #32
0
 public BackupService(IConnectionRepository connectionRepository, IClientRepository clientRepository)
 {
     _connectionRepository = connectionRepository;
     _clientRepository     = clientRepository;
 }
Example #33
0
        public void Init()
        {
            _validUserCreator = new User()
            {
                CreationDate = DateTime.Now,
                EMail        = "*****@*****.**",
                FullName     = "Sammy le Crabe",
                Id           = 646,
                IsValid      = true,
                Password     = new byte[] { 0 },
                UserName     = "******"
            };

            _validUserNonCreator = new User()
            {
                CreationDate = DateTime.Now,
                EMail        = "*****@*****.**",
                FullName     = "Jack le Crabe",
                Id           = 7215,
                IsValid      = true,
                Password     = new byte[] { 0 },
                UserName     = "******"
            };

            _invalidUser = new User()
            {
                CreationDate = DateTime.Now,
                EMail        = "*****@*****.**",
                FullName     = "Nop le Crabe",
                Id           = 2765,
                IsValid      = false,
                Password     = new byte[] { 0 },
                UserName     = "******"
            };

            _validClient = new Client()
            {
                ClientSecret  = "abcdefghijklmnopqrstuv",
                ClientTypeId  = 1,
                CreationDate  = DateTime.Now,
                Description   = "test",
                Id            = 777,
                IsValid       = true,
                Name          = "test",
                PublicId      = "abc",
                UserCreatorId = _validUserCreator.Id
            };

            _anotherValidClient = new Client()
            {
                ClientSecret  = "fghjzertukh",
                ClientTypeId  = 1,
                CreationDate  = DateTime.Now,
                Description   = "test again",
                Id            = 778,
                IsValid       = true,
                Name          = "test again",
                PublicId      = "def",
                UserCreatorId = _validUserCreator.Id
            };

            _invalidClient = new Client()
            {
                ClientSecret  = "abcdefghijklmnopqrstuv",
                ClientTypeId  = 1,
                CreationDate  = DateTime.Now,
                Description   = "test_invalid",
                Id            = 776,
                IsValid       = false,
                Name          = "test_invalid",
                PublicId      = "abc_invalid",
                UserCreatorId = _invalidUser.Id
            };

            FakeDataBase.Instance.Clients.Add(_validClient);
            FakeDataBase.Instance.Clients.Add(_invalidClient);
            FakeDataBase.Instance.Clients.Add(_anotherValidClient);
            FakeDataBase.Instance.Users.Add(_validUserCreator);
            FakeDataBase.Instance.Users.Add(_validUserNonCreator);
            FakeDataBase.Instance.Users.Add(_invalidUser);

            _clientReturnUrl = new ClientReturnUrl()
            {
                Id        = 6131,
                ClientId  = _validClient.Id,
                ReturnUrl = "http://www.perdu.com"
            };

            FakeDataBase.Instance.ClientReturnUrls.Add(_clientReturnUrl);

            _scope = new Scope()
            {
                Id = 2245,
                RessourceServerId = 1,
                Wording           = "test",
                NiceWording       = "test"
            };

            FakeDataBase.Instance.Scopes.Add(_scope);

            FakeDataBase.Instance.ClientsScopes.Add(new ClientScope()
            {
                Id       = 154,
                ClientId = _validClient.Id,
                ScopeId  = _scope.Id
            });

            FakeDataBase.Instance.UsersClient.Add(new UserClient()
            {
                ClientId     = _invalidClient.Id,
                CreationDate = DateTime.Now,
                Id           = 9595,
                IsActif      = true,
                UserId       = _validUserCreator.Id
            });
            FakeDataBase.Instance.UsersClient.Add(new UserClient()
            {
                ClientId     = _validClient.Id,
                CreationDate = DateTime.Now,
                Id           = 378,
                IsActif      = true,
                UserId       = _validUserCreator.Id
            });
            FakeDataBase.Instance.UsersClient.Add(new UserClient()
            {
                ClientId     = _validClient.Id,
                CreationDate = DateTime.Now,
                Id           = 3784,
                IsActif      = true,
                UserId       = _validUserNonCreator.Id
            });
            FakeDataBase.Instance.UsersClient.Add(new UserClient()
            {
                ClientId     = _validClient.Id,
                CreationDate = DateTime.Now,
                Id           = 3785,
                IsActif      = true,
                UserId       = _invalidUser.Id
            });

            _service = new ClientService()
            {
                Configuration          = FakeConfigurationHelper.GetFakeConf(),
                RepositoriesFactory    = new FakeRepositoriesFactory(),
                StringLocalizerFactory = new FakeStringLocalizerFactory(),
                Logger        = new FakeLogger(),
                RandomService = new FakeRandomService(1, _generatedClientSecret)
            };

            _repo = new FakeClientRepository();
        }
Example #34
0
 public ClientCommandHandler(IClientRepository clientRepository)
 {
     _clientRepository = clientRepository;
 }
Example #35
0
 public ClientService(IClientRepository clientRepository) : base(clientRepository)
 {
 }
Example #36
0
 public AppointmentController(IAppointmentRepository appointmentRepository, IAppointmentTypeRepository appointmentTypeRepository, IClientRepository clientRepository, ITherapistRepository therapistRepository, IMapper mapper)
 {
     _appointmentRepository     = appointmentRepository;
     _appointmentTypeRepository = appointmentTypeRepository;
     _clientRepository          = clientRepository;
     _therapistRepository       = therapistRepository;
     _mapper = mapper;
 }
 public AddClientCommand(IUIFactory uiFactory, DomainFactory factory, IClientRepository repository)
 {
     this.uiFactory  = uiFactory;
     this.factory    = factory;
     this.repository = repository;
 }
 public UpdateClientCommandHandler(IClientRepository clientRepository, IClientUpdateSender clientUpdateSender)
 {
     _clientRepository   = clientRepository;
     _clientUpdateSender = clientUpdateSender;
 }
Example #39
0
 public ClientController(IClientRepository iClientRepository, ILogger <ClientController> logger)
 {
     _clientRepository = iClientRepository;
     _logger           = logger;
 }
 public ClientCacheService(IClientRepository clientRepository)
 {
     this.clientRepository = clientRepository;
 }
Example #41
0
 public CorsPolicyService(
     IClientRepository clientRepository)
 {
     _clientRepository = clientRepository;
 }
Example #42
0
 public LoginService(IClientRepository clientRepository)
 {
     _clientRepository = clientRepository;
 }
Example #43
0
 public ClienteController(IClientRepository repository)
 {
     _repository = repository;
 }
Example #44
0
 public ClientService(IClientRepository repository)
 {
     this.repository = repository;
 }
Example #45
0
 public ClientGetAllService(IClientRepository clientRepository)
 {
     _clientRepository = clientRepository;
 }
Example #46
0
 public UnitOfWork(ClientOrderContext context)
 {
     this.context = context;
     Orders       = new OrderRepository(context);
     Clients      = new ClientRepository(context);
 }
 public ClientService(IClientRepository _clientRepository)
 {
     this.clientRepository = _clientRepository;
 }
 public ClientService(IClientRepository IClientRepository)
 {
     this.IClientRepository = IClientRepository;
 }
 public ClientAppService(IClientRepository clientRepository)
 {
     ClientRepository = clientRepository;
 }
        private IClientService GetClientService(IClientRepository repository, IClientServiceResources resources)
        {
            IClientService clientService = new ClientService(repository, resources);

            return(clientService);
        }
Example #51
0
 public CheckingAccountService(ICheckingAccountRepository checkingAccountRepository, IClientRepository clientRepository, ITransactionRepository transactionRepository)
 {
     _checkingAccountRepository = checkingAccountRepository;
     _clientRepository          = clientRepository;
     _transactionRepository     = transactionRepository;
 }
 public DeliveryCreatedIntegrationEventHandler(IDeliveryService deliveryService,
                                               IClientGrpcService clientGrpcService, IClientRepository clientRepository, IMapper mapper,
                                               ILogger <DeliveryCreatedIntegrationEventHandler> logger)
 {
     _deliveryService   = deliveryService;
     _clientGrpcService = clientGrpcService;
     _clientRepository  = clientRepository;
     _mapper            = mapper;
     _logger            = logger;
 }
Example #53
0
 public ClientController(IClientRepository repo)
 {
     _repo = repo;
 }
 public ClientService(IClientRepository clientRepository, IClientServiceResources clientServiceResources)
 {
     _clientRepository       = clientRepository;
     _clientServiceResources = clientServiceResources;
 }
 public GraphQLService(IClientRepository repository)
 {
     this.repository = repository;
 }
 public UpdateVacancyCommandHandler(IClientRepository repo)
 {
     _repo = repo;
 }
Example #57
0
 /// <summary>
 /// Инициализирует хранилище клиентов.
 /// </summary>
 /// <param name="clientRepository">
 /// Репозиторий клиентов (например, rest-клиент).
 /// </param>
 /// <param name="scopes">
 /// Набор scope-ов, который назначается всем клиентам.
 /// <see cref="Scope"/> - класс как часть api identity server, за информацией по ним
 /// см. документацию.
 /// </param>
 /// <param name="isWindowsAuth">
 /// Используется ли хранилище для работы с windows-клиентами (wpf, winforms).
 /// Один объект хранилища может работать либо только с не windows-клиентам (то есть с сайтам),
 /// либо только с windows-клинетами (то есть с приложениями).
 /// </param>
 public CustomClientStore(IClientRepository clientRepository, IEnumerable <Scope> scopes, bool isWindowsAuth = false)
 {
     this.IsWindowsAuth    = isWindowsAuth;
     this.ClientRepository = clientRepository;
     this.Scopes           = scopes;
 }
Example #58
0
 public IQueryable <ClientVersion> GetVersions(
     [Parent] Client client,
     [Service] IClientRepository repository) =>
 repository.GetClientVersions().Where(t => t.ClientId == client.Id);
Example #59
0
 public ClientsController(IClientRepository clientRepository)
 {
     _clientRepository = clientRepository;
 }
Example #60
0
 /// <summary>Initializes a new instance of the <see cref="ClientManager" /> class.</summary>
 /// <param name="logger">The logger.</param>
 /// <param name="passwordCryptoProvider">The password crypto provider.</param>
 /// <param name="asymmetricCryptoProvider">The asymmetric crypto provider.</param>
 /// <param name="clientRepository">The client repository.</param>
 public ClientManager(ILog logger, IPasswordCryptoProvider passwordCryptoProvider, IAsymmetricCryptoProvider asymmetricCryptoProvider, IClientRepository clientRepository)
     : base(logger, passwordCryptoProvider, asymmetricCryptoProvider, clientRepository)
 {
 }