public SalesController(IClientRepository clientRepository, ISaleRepository saleRepository,
ILotteryRepository lotteryRepository)
{
_clientRepository = clientRepository;
_saleRepository = saleRepository;
_lotteryRepository = lotteryRepository;
}
public ClientExcelHelper(
IClientRepository clients,
IExcelClientCalculation excel)
{
_clients = clients;
_excel = excel;
}
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;
}
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;
}
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;
}
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);
};
}
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());
}
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;
}
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;
}
public BalanceController(
IClientRepository clients,
IClientBalance balance,
IClientBalanceRepository balanceRepository)
{
_clients = clients;
_balance = balance;
_balanceRepository = balanceRepository;
}
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;
}
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>();
}
public ClientLogic(IClientRepository repository)
{
_repository = repository;
Mapper.Initialize(cfg =>
{
cfg.CreateMap<ClientAddressPoco, ClientAddressDto>();
cfg.CreateMap<ClientPoco, ClientDto>();
});
}
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;
}
public BackupService(IConnectionRepository connectionRepository, IClientRepository clientRepository)
{
_connectionRepository = connectionRepository;
_clientRepository = clientRepository;
}
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();
}
public ClientCommandHandler(IClientRepository clientRepository)
{
_clientRepository = clientRepository;
}
public ClientService(IClientRepository clientRepository) : base(clientRepository)
{
}
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;
}
public ClientController(IClientRepository iClientRepository, ILogger <ClientController> logger)
{
_clientRepository = iClientRepository;
_logger = logger;
}
public ClientCacheService(IClientRepository clientRepository)
{
this.clientRepository = clientRepository;
}
public CorsPolicyService(
IClientRepository clientRepository)
{
_clientRepository = clientRepository;
}
public LoginService(IClientRepository clientRepository)
{
_clientRepository = clientRepository;
}
public ClienteController(IClientRepository repository)
{
_repository = repository;
}
public ClientService(IClientRepository repository)
{
this.repository = repository;
}
public ClientGetAllService(IClientRepository clientRepository)
{
_clientRepository = clientRepository;
}
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);
}
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;
}
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;
}
/// <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;
}
public IQueryable <ClientVersion> GetVersions(
[Parent] Client client,
[Service] IClientRepository repository) =>
repository.GetClientVersions().Where(t => t.ClientId == client.Id);
public ClientsController(IClientRepository clientRepository)
{
_clientRepository = clientRepository;
}
/// <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)
{
}
