public ClienteDataManagerImpl()
{
_service = new ClienteService();
_control = new ClienteControl();
}
public ContactoController(
IContactoService ContactoService,
IClienteService ClienteService)
{
this._ContactoService = ContactoService;
this._ClienteService = ClienteService;
}
public UsuarioService(IUsuarioRepository repository, IServicoService servico, IClienteService cliente)
{
//this._logger = logger;
this._repository = repository;
this._queryParams = new Dictionary<string, object>();
_servico = servico;
_cliente = cliente;
}
public ClienteController(IClienteService ClienteService, IPedidoService PedidoService, IIndustriaService IndustriaService, IUsuarioService UsuarioService, IContactoService ContactoService, IDireccionService DireccionService)
{
this._ClienteService = ClienteService;
this._PedidoService = PedidoService;
this._UsuarioService = UsuarioService;
this._IndustriaService = IndustriaService;
this._ContactoService = ContactoService;
this._DireccionService = DireccionService;
}
public OperacionesController(IPedidoService PedidoService, IPedidoDetalleService PedidoDetalleService, IClienteService ClienteService, IEstadoDetalleService EstadoDetalleService, IEstadoPedidoService EstadoPedidoService, ICatalogoService CatalogoService, IMonedaService MonedaService)
{
_PedidoService = PedidoService;
_EstadoPedidoService = EstadoPedidoService;
_CatalogoService = CatalogoService;
_MonedaService = MonedaService;
_EstadoDetalleService = EstadoDetalleService;
_ClienteService = ClienteService;
_PedidoDetalleService = PedidoDetalleService;
}
public AcompanhamentoDiarioController(IClienteService clienteService,
IContratoService contratoService,
IProfissionalService profissionalService,
IRelatorioService relatorioService)
{
_clienteService = clienteService;
_contratoService = contratoService;
_profissionalService = profissionalService;
_relatorioService = relatorioService;
_contratoMapper = new AutoMapperContrato();
_clienteMapper = new AutoMapperCliente();
_profissionalMapper = new AutoMapperProfissional();
_filtrosMapper = new AutoMapperAcompanhamentoDiario();
}
public ClienteWindowViewModel(IDialogCoordinator dialog)
{
this.dialog = dialog;
//main = new MainWindowViewModel(this.dialog);
clienteService = new ClienteService(new ClienteRepository());
IncluirCommand = new DelegateCommand(Incluir, () => !ModoEdicao).ObservesProperty(() => ModoEdicao);
AlterarCommand = new DelegateCommand(Alterar, () => ModoEdicao).ObservesProperty(() => ModoEdicao);
InativarCommand = new DelegateCommand(Inativar, () => ModoEdicao).ObservesProperty(() => ModoEdicao);
LimparTelaCommand = new DelegateCommand(Limpar);
BuscarClientes();
}
public EncomientaController(IVentaService ventaService, IEstacionService estacionService,
IHorarioService horarioService, IVentaAsientoService ventaAsientoService,
ICargaService cargaService, IClienteService clienteService,
IVehiculoService vehiculoService, IMovCuentaService movCuentaService)
{
this.ventaService = ventaService;
this.estacionService = estacionService;
this.horarioService = horarioService;
this.ventaAsientoService = ventaAsientoService;
this.cargaService = cargaService;
this.clienteService = clienteService;
this.vehiculoService = vehiculoService;
this.movCuentaService = movCuentaService;
}
public PedidoAppService(IPedidoRepository repository,
IClienteRepository clienteRepository,
IPedidoService service,
IClienteService clienteService,
IPizzaRepository pizzaRepository,
IUnitOfWork uow)
{
_repository = repository;
_clienteRepository = clienteRepository;
_service = service;
_pizzaRepository = pizzaRepository;
_clienteService = clienteService;
_uow = uow;
}
public ContratoController(IContratoService contratoService,
IClienteService clienteService,
IAlocacaoService alocacaoService,
IProfissionalService profissionalService)
{
_contratoService = contratoService;
_clienteService = clienteService;
_alocacaoService = alocacaoService;
_profissionalService = profissionalService;
_contratoMapper = new AutoMapperContrato();
_alocacaoMaper = new AutoMapperAlocacao();
_profissionalMapper = new AutoMapperProfissional();
}
public ClienteController
(
INotificador notificador,
IClienteService clienteService,
IClienteRepository clienteRepository,
IUsuarioService usuarioService,
IContaService contaService
) : base(notificador)
{
_clienteService = clienteService;
_clienteRepository = clienteRepository;
_usuarioService = usuarioService;
_contaService = contaService;
}
public void Dispose()
{
_clienteService = null;
_asientoService = null;
_teatroService = null;
_obraService = null;
_funcionService = null;
_promocionService = null;
_reservaService = null;
_tipoPromocionService = null;
_zonaService = null;
_emailService = null;
_empresaService = null;
}
public ReportingBusiness(IClienteService clienteService, IInscricaoService inscricaoService)
{
m_ClienteService = clienteService;
m_InscricaoService = inscricaoService;
listaCelulas = new List <string>()
{
"A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "X", "Y", "Z",
"AA", "AB", "AC", "AD", "AE", "AF", "AG", "AH", "AI", "AJ", "AK", "AL", "AM", "AN", "AO", "AP", "AQ", "AR", "AS", "AT", "AU", "AV", "AX", "AY", "AZ"
};
dicionarioColunas = new Dictionary <string, string>
{
{ "Id", "Código" },
{ "Nome", "Nome" },
{ "Email", "Email" },
{ "Rg", "Rg" },
{ "Orgaoemissor", "Orgao Emissão" },
{ "Ufemissor", "Uf Emissão" },
{ "Dtemissao", "Emissão" },
{ "Cpf", "Cpf" },
{ "Nacionalidade", "Nacionalidade" },
{ "Naturalidade", "Naturalidade" },
{ "Dtnascimento", "Nascimento" },
{ "Sexo", "Sexo" },
{ "Nomepai", "Nome Pai" },
{ "Nomemae", "Nome Mãe" },
{ "Cep", "Cep" },
{ "Endereco", "Endereço" },
{ "Bairro", "Bairro" },
{ "Numero", "Numero" },
{ "Complemento", "Complemento" },
{ "Cidade", "Cidade" },
{ "Estado", "Estado" },
{ "Telresidencial", "Tel. Residencial" },
{ "Telcomercial", "Tel. Comercial" },
{ "Telcelular", "Tel. Celular" },
{ "Cadadministracao", "Cad Administração" },
{ "Enviosenha", "Envio Senha" },
{ "Orgaotrabalhoid", "Orgão Trabalho" },
{ "Escolaridadeid", "Escolaridade" },
{ "Instituicao", "Instituição" },
{ "Dtconclusao", "Conclusão" },
{ "Dtregistro", "Registro" },
{ "Dtultimaalteracao", "Última Alteração" },
{ "Dtultimoacesso", "Último acessso" },
{ "Idantigo", "Antigo" },
{ "Qtdacesso", "Acesso" },
{ "Receberfeeds", "Receber Feeds" }
};
}
public ClientesController(
IMapper mapper,
IClienteService clienteService,
IClienteRepository clienteRepository,
JwtTokenGenerate jwtTokenGenerate,
INotificationHandler <DomainNotification> notifications,
IUser user,
IMediatorHandler mediator)
: base(notifications, user, mediator)
{
_mapper = mapper;
_clienteService = clienteService;
_clienteRepository = clienteRepository;
_jwtTokenGenerate = jwtTokenGenerate;
}
public PedidoController(IPedidoService PedidoService, IAdjuntoService AdjuntoService, IPedidoDetalleService PedidoDetalleService, ICatalogoService CatalogoService, IModalidadService ModalidadService, IMonedaService MonedaService, IHerramientaService HerramientaService, IEstadoDetalleService EstadoDetalleService, IEstadoPedidoService EstadoPedidoService, IClienteService ClienteService, IUsuarioService UsuarioService, IPatenteService PatenteService)
{
this._PedidoService = PedidoService;
this._AdjuntoService = AdjuntoService;
this._PedidoDetalleService = PedidoDetalleService;
this._CatalogoService = CatalogoService;
this._ModalidadService = ModalidadService;
this._MonedaService = MonedaService;
this._HerramientaService = HerramientaService;
this._EstadoDetalleService = EstadoDetalleService;
this._EstadoPedidoService = EstadoPedidoService;
this._ClienteService = ClienteService;
this._UsuarioService = UsuarioService;
this._PatenteService = PatenteService;
}
public UsuariosController(
IClienteService clienteService,
IClienteIdentityService clienteIdentityService,
IClienteRepository clienteRepository,
JwtTokenGenerate jwtTokenGenerate,
INotificationHandler <DomainNotification> notifications,
IUser user,
IMediatorHandler mediator)
: base(notifications, user, mediator)
{
_clienteService = clienteService;
_clienteIdentityService = clienteIdentityService;
_clienteRepository = clienteRepository;
_jwtTokenGenerate = jwtTokenGenerate;
}
public ClienteController(IClienteService service, ITokenManager tokenManager, IAuthenticationApiConsumer authenticationApiConsumer, IClienteApiConsumer ClienteApiConsumer, ISpartane_FileApiConsumer Spartane_FileApiConsumer, ISpartan_Business_RuleApiConsumer Spartan_Business_RuleApiConsumer, ISpartan_BR_Process_Event_DetailApiConsumer Spartan_BR_Process_Event_DetailApiConsumer, ISpartan_FormatApiConsumer Spartan_FormatApiConsumer, ISpartan_Format_PermissionsApiConsumer Spartan_Format_PermissionsApiConsumer, IGeneratePDFApiConsumer GeneratePDFApiConsumer, ISpartan_Format_RelatedApiConsumer Spartan_Format_RelatedApiConsumer)
{
this.service = service;
this._IAuthenticationApiConsumer = authenticationApiConsumer;
this._IClienteApiConsumer = ClienteApiConsumer;
this._userCredential = SessionHelper.UserCredential;
this._tokenManager = tokenManager;
this._ISpartane_FileApiConsumer = Spartane_FileApiConsumer;
this._ISpartan_Business_RuleApiConsumer = Spartan_Business_RuleApiConsumer;
this._ISpartan_BR_Process_Event_DetailApiConsumer = Spartan_BR_Process_Event_DetailApiConsumer;
this._ISpartan_FormatApiConsumer = Spartan_FormatApiConsumer;
this._ISpartan_Format_PermissionsApiConsumer = Spartan_Format_PermissionsApiConsumer;
this._IGeneratePDFApiConsumer = GeneratePDFApiConsumer;
this._ISpartan_FormatRelatedApiConsumer = Spartan_Format_RelatedApiConsumer;
}
public async Task <ActionResult> GetAll([FromServices] IClienteService service)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
try
{
return(Ok(await _service.GetAll()));
}
catch (ArgumentException e)
{
return(StatusCode((int)HttpStatusCode.InternalServerError, e.Message));
}
}
private static void Inyection()
{
_services = new ServiceCollection();
_services.AddDbContext <Contexto>();
_services.AddTransient <IGenericRepository, GenericsRepository>();
_services.AddTransient <ILibroService, LibroService>();
_services.AddTransient <ILibroQuery, LibroQuery>();
libroService = _services.BuildServiceProvider().GetRequiredService <ILibroService>();
_services.AddTransient <IClienteService, ClienteService>();
_services.AddTransient <IClienteQuery, ClienteQuery>();
clienteService = _services.BuildServiceProvider().GetRequiredService <IClienteService>();
_services.AddTransient <IAlquileresService, AlquileresService>();
_services.AddTransient <IAlquileresQuery, AlquileresQuery>();
alquilerService = _services.BuildServiceProvider().GetRequiredService <IAlquileresService>();
}
public BaseController()
{
this._usuarioService = DependencyResolver.Current.GetService<IUsuarioService>();
this._servicoService = DependencyResolver.Current.GetService<IServicoService>();
this._clienteService = DependencyResolver.Current.GetService<IClienteService>();
try
{
if (Session["IdServico"] == null) { RedirectToAction("EncerrarAcesso", "Login"); }
}
catch
{
TempData["Error"] = "Sessão expirou, porfavor efetuar login...";
RedirectToAction("EncerrarAcesso", "Login");
}
}
public VendasController(IClienteService clienteService,
IProdutoService produtoService,
ITipoPagamentoService tipoPagamentoService,
IVendedorService vendedorService,
IPedidoService pedidoService,
IItemPedidoService itemPedidoService,
IFormaPagamentoService formaPagamentoService)
{
_clienteService = clienteService;
_produtoService = produtoService;
_tipoPagamentoService = tipoPagamentoService;
_vendedorService = vendedorService;
_pedidoService = pedidoService;
_itemPedidoService = itemPedidoService;
_formaPagamentoService = formaPagamentoService;
}
public ChamadoController(IChamadoService chamadoService, IMapper mapper, IClienteService clienteService, IUsuarioService usuarioService, UserManager <IdentityUser> userManager,
IEquipamentoService serieService, IClienteSerieService clienteSerieService, ISerieSubConjuntoService serieSubConjuntoService, ISubConjuntoService subConjuntoService, ITecnicoService tecnicoService,
IEmpresaUsuarioService empresaUsuarioService)
{
_chamadoService = chamadoService;
_mapper = mapper;
_clienteService = clienteService;
_usuarioService = usuarioService;
_serieService = serieService;
_clienteSerieService = clienteSerieService;
_serieSubConjuntoService = serieSubConjuntoService;
_subConjuntoService = subConjuntoService;
_userManager = userManager;
_tecnicoService = tecnicoService;
_empresaUsuarioService = empresaUsuarioService;
}
public ClienteApp(
IMediatorHandler bus,
IClienteService clienteService,
ListNotificacoes <Notificacao> notificacoes,
EventStoreContexto eventStoreContexto,
IUser user,
IMapper mapper,
IUnitOfWork unitOfWork)
: base(notificacoes, unitOfWork)
{
_clienteService = clienteService;
_bus = bus;
_user = user;
_mapper = mapper;
_eventStoreContexto = eventStoreContexto;
}
public UnitTest()
{
var webHost = WebHost.CreateDefaultBuilder()
.UseStartup <Startup>()
.UseEnvironment("Development")
.Build();
_serviceProvider = new DependencyResolverHelpercs(webHost);
_usuarioService = _serviceProvider.GetService <IUsuarioService>();
_clienteService = _serviceProvider.GetService <IClienteService>();
_instituicaoEnsinoService = _serviceProvider.GetService <IInstituicaoEnsinoService>();
_livroService = _serviceProvider.GetService <ILivroService>();
_emprestimoService = _serviceProvider.GetService <IEmprestimoService>();
_clienteBloqueioService = _serviceProvider.GetService <IClienteBloqueioService>();
_unitOfWork = _serviceProvider.GetService <IUnitOfWork>();
}
protected void Page_Load(object sender, EventArgs e)
{
try
{
this.HasPermissionToSeeMe(Operaciones.ClienteDetalle);
if (this.BaseMaster.EsCliente)
{
this.lblTituloPagina.Text = "Mis Datos";
this.btnVerAuditoria.Visible = false;
}
else
{
this.btnVerAuditoria.Visible = true;
}
IClienteService clienteService = ServiceFactory.GetClienteService();
if (!this.IsPostBack)
{
if (this.BaseMaster.EsCliente)
{
clienteCurrent = clienteService.ObtenerCliente(this.BaseMaster.ClienteId);
this.txtCuit.Enabled = false;
this.txtRazonSocial.Enabled = false;
this.btnCancelar.Visible = false;
this.chkCalculaVencimientoConVisualizacionDoc.Enabled = false;
}
else if (this.Request.QueryString["Id"] == null)
{
clienteCurrent = new ClienteDto();
}
else
{
clienteCurrent = clienteService.ObtenerCliente(Convert.ToInt64(this.Request.QueryString["Id"]));
}
Bindear();
}
}
catch (Exception ex)
{
ExceptionManager.Instance.HandleException(ex);
}
}
public ClienteController(IClienteService clienteService,
IClienteRepository clienteRepository,
ILogGenericoRepository logGenericoRepository,
NotificationHandler notificationHandler,
IOptions <ConnectionStrings> connectionStrings,
IGrupoClienteService grupoClienteService,
IEnderecoService enderecoService,
IPaisRepository paisRepository)
{
_clienteService = clienteService;
_clienteRepository = clienteRepository;
_logGenericoRepository = logGenericoRepository;
_notificationHandler = notificationHandler;
_connectionStrings = connectionStrings;
_grupoClienteService = grupoClienteService;
_enderecoService = enderecoService;
_paisRepository = paisRepository;
}
public AdminController()
{
_usuarioRepository = new UsuarioRepository();
_usuarioService = new UsuarioService(_usuarioRepository);
_rolRepository = new RolRepository();
_rolService = new RolService(_rolRepository, _usuarioRepository);
_permisoRepository = new PermisoRepository();
_permisoService = new PermisoService(_permisoRepository);
_sesionUsuario = new SessionCacheStorageService();
_maestroRepository = new MaestroRepository();
_maestroService = new MaestroService(_maestroRepository);
_clienteRepository = new ClienteRepository();
_clienteService = new ClienteService(_clienteRepository);
_proyectoRepository = new ProyectoRepository();
_proyectoService = new ProyectoService(_proyectoRepository, _clienteRepository);
}
private void Save()
{
IClienteService clienteSvc = ServiceFactory.GetClienteService();
var userIdentity = UIHelper.GetCustomIdentity();
if (userIdentity != null)
{
clienteCurrent.Auditoria_UsuarioId = userIdentity.UserId;
}
if (clienteCurrent.Id == 0)
{
clienteCurrent = clienteSvc.CrearCliente(clienteCurrent);
}
else
{
clienteCurrent = clienteSvc.EditarCliente(clienteCurrent);
}
}
public ChamadoService(IChamadoRepository chamadoRepository, IChamadoSubConjuntoService chamadoSubConjuntoService, IMapper mapper, IClienteService clienteService,
IChamadoProdutoService chamadoProdutoService, IChamadoImagemService chamadoImagemService, IImagemService imagemService, ITecnicoService tecnicoService, ISubConjuntoService subConjuntoService,
IEquipamentoService serieService, IProdutoService produtoService, ISerieSubConjuntoService serieSubConjuntoService, IUsuarioService usuarioService, IEmpresaUsuarioService empresaUsuarioService)
: base(chamadoRepository)
{
_chamadoRepository = chamadoRepository;
_chamadoProdutoService = chamadoProdutoService;
_chamadoSubConjuntoService = chamadoSubConjuntoService;
_mapper = mapper;
_chamadoImagemService = chamadoImagemService;
_imagemService = imagemService;
_clienteService = clienteService;
_tecnicoService = tecnicoService;
_subConjuntoService = subConjuntoService;
_serieService = serieService;
_produtoService = produtoService;
_serieSubConjuntoService = serieSubConjuntoService;
_usuarioService = usuarioService;
_empresaUsuarioService = empresaUsuarioService;
}
public async Task E_Possivel_Executar_Metodo_Update()
{
_serviceMock = new Mock <IClienteService>();
_serviceMock.Setup(m => m.Post(clienteDtoCreate)).ReturnsAsync(clienteDtoCreateResult);
_service = _serviceMock.Object;
var result = await _service.Post(clienteDtoCreate);
Assert.NotNull(result);
Assert.Equal(NomeCliente, result.Nome);
_serviceMock = new Mock <IClienteService>();
_serviceMock.Setup(m => m.Put(clienteDtoUpdate)).ReturnsAsync(clienteDtoUpdateResult);
_service = _serviceMock.Object;
var resultUpdate = await _service.Put(clienteDtoUpdate);
Assert.NotNull(resultUpdate);
Assert.Equal(NomeClienteAlterado, resultUpdate.Nome);
}
public async Task E_Possivel_Executar_Metodo_Delete()
{
_serviceMock = new Mock <IClienteService>();
_serviceMock.Setup(m => m.Delete(IdCliente))
.ReturnsAsync(true);
_service = _serviceMock.Object;
var deletado = await _service.Delete(IdCliente);
Assert.True(deletado);
_serviceMock = new Mock <IClienteService>();
_serviceMock.Setup(m => m.Delete(It.IsAny <Guid>()))
.ReturnsAsync(false);
_service = _serviceMock.Object;
deletado = await _service.Delete(Guid.NewGuid());
Assert.False(deletado);
}
public async Task E_Possivel_Executar_Metodo_Get()
{
_serviceMock = new Mock <IClienteService>();
_serviceMock.Setup(m => m.Get(IdCliente)).ReturnsAsync(clienteDto);
_service = _serviceMock.Object;
var result = await _service.Get(IdCliente);
Assert.NotNull(result);
Assert.True(result.Id == IdCliente);
Assert.Equal(NomeCliente, result.Nome);
_serviceMock = new Mock <IClienteService>();
_serviceMock.Setup(m => m.Get(It.IsAny <Guid>())).Returns(Task.FromResult((ClienteDto)null));
_service = _serviceMock.Object;
var _record = await _service.Get(IdCliente);
Assert.Null(_record);
}
public PersonasLibresController()
{
_PersonaLibreRepository = new PersonaLibreRepository();
_sesionPersonasLibres = new SessionCacheStorageService();
_PersonaLibreService = new PersonaLibreService(_PersonaLibreRepository);
_sesionEmpleadosFenix = new SessionCacheStorageService();
_EmpleadoFenixService = new EmpleadosFenixService();
_necesidadRepository = new NecesidadRepository();
_necesidadService = new NecesidadService(_necesidadRepository);
_maestroRepository = new MaestroRepository();
_maestroService = new MaestroService(_maestroRepository);
_clienteRepository = new ClienteRepository();
_clienteService = new ClienteService(_clienteRepository);
_proyectoRepository = new ProyectoRepository();
_proyectoService = new ProyectoService(_proyectoRepository, _clienteRepository);
_grupoNecesidadRepository = new GrupoNecesidadRepository();
_grupoNecesidadService = new GrupoNecesidadService(_grupoNecesidadRepository, _necesidadRepository);
}
public async Task E_Possivel_Executar_Metodo_GetAll()
{
_serviceMock = new Mock <IClienteService>();
_serviceMock.Setup(m => m.GetAll()).ReturnsAsync(listaClienteDto);
_service = _serviceMock.Object;
var result = await _service.GetAll();
Assert.NotNull(result);
Assert.True(result.Count() == 10);
var _listResult = new List <ClienteDto>();
_serviceMock = new Mock <IClienteService>();
_serviceMock.Setup(m => m.GetAll()).ReturnsAsync(_listResult.AsEnumerable);
_service = _serviceMock.Object;
var _resultEmpty = await _service.GetAll();
Assert.Empty(_resultEmpty);
Assert.True(_resultEmpty.Count() == 0);
}
public CategoriaVagaService
(
IRepository <CategoriaVaga> repository,
IRepository <Vaga> vagaRepository,
IRepository <Reserva> reservaRepository,
IFuncionarioService funcionarioService,
IClienteService clienteService,
CategoriaVagaValidator categoriaVagaValidator,
Usuario usuarioLogado
)
: base(repository, categoriaVagaValidator, usuarioLogado)
{
this.vagaRepository = vagaRepository;
this.reservaRepository = reservaRepository;
this.funcionarioService = funcionarioService;
this.clienteService = clienteService;
this.categoriaVagaValidator = categoriaVagaValidator;
}
protected void Page_Load(object sender, EventArgs e)
{
try
{
HasPermissionToSeeMe(Operaciones.MensajesAlertasClientes);
this.clienteSvc = ServiceFactory.GetClienteService();
if (!this.IsPostBack)
{
if (this.Request.QueryString["Id"] != null)
{
ClienteDto client = this.clienteSvc.ObtenerCliente(long.Parse(this.Request.QueryString["Id"].ToString()));
this.ClienteId = client.Id;
this.lblCliente.Text = client.RazonSocial;
}
this.Buscar();
}
}
catch (Exception ex)
{
ExceptionManager.Instance.HandleException(ex);
}
}
private static void DIP_Test()
{
ninjectKernel = new StandardKernel();
InjetarDependencia();
IClienteService clienteService = ninjectKernel.Get <IClienteService>();
ICPFServices cpfServices = ninjectKernel.Get <ICPFServices>();
IEmailServices emailServices = ninjectKernel.Get <IEmailServices>();
Cliente cliente = new Cliente(cpfServices, emailServices)
{
ClientId = 1,
CPF = "12345678913",
DataCadastro = DateTime.Now,
Email = "*****@*****.**",
Nome = "Test Name"
};
string result = clienteService.AdicionarCliente(cliente);
Console.WriteLine(result);
}
public void Initialize()
{
_mockRepository = new Mock <IClienteRepository>();
_mockUnitWork = new Mock <IUnitOfWork>();
_service = new ClienteService(_mockUnitWork.Object, _mockRepository.Object);
listCountry = new List <Cliente>()
{
new Cliente()
{
Nombres = "Elvis", Apellidos = "Aguirre"
},
new Cliente()
{
Nombres = "Pedro", Apellidos = "Del Solar"
},
new Cliente()
{
Nombres = "Juan", Apellidos = "Susanibar"
}
};
var ServiceBaseURL = "http://localhost:65413/";
//Arrange
_mockRepository.Setup(x => x.GetAll()).Returns(listCountry);
controller = new ClienteController(_service)
{
Request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri(ServiceBaseURL + "api/Country")
}
};
controller.Request.Properties.Add(HttpPropertyKeys.HttpConfigurationKey, new HttpConfiguration());
}
public ServicoController()
{
this._servicoService = DependencyResolver.Current.GetService<IServicoService>();
this._clienteService = DependencyResolver.Current.GetService<IClienteService>();
}
public FrmClientes()
{
InitializeComponent();
clienteService = new ClienteService(new AlmacenORMDataContext());
}
public ClienteController(IClienteService ClienteService, IPedidoService PedidoService)
{
_ClienteService = ClienteService;
_PedidoService = PedidoService;
}
public ClienteAppService(IClienteService clienteService, IUnitOfWork uow)
: base(uow)
{
_clienteService = clienteService;
}
public ClienteController(IClienteService clienteService)
{
this.clienteService = clienteService;
}
public NovoClienteApplicationService(IClienteService clienteService)
{
_clienteService = clienteService;
}
public ClienteAppService(IClienteService service)
{
_service = service;
}
public ClienteController(IClienteService clienteService, IMovCuentaService movCuentaService)
{
this.clienteService = clienteService;
this.movCuentaService = movCuentaService;
}
public ClientesController(IClienteService service)
{
this.Service = service;
}
public ClienteController(IClienteService service, IUsuarioService idService)
{
this.service = service;
this.identityService = idService;
}
public PedidoController(IPedidoService PedidoService, IClienteService ClienteService, IPedidoDetalleService PedidoDetalleService)
{
_PedidoService = PedidoService;
_ClienteService = ClienteService;
_PedidoDetalleService = PedidoDetalleService;
}
public FrmClienteForm()
{
InitializeComponent();
clienteService = new ClienteService(new Repository<Cliente>());
clienteMapper = new ClienteMapper(new Repository<Cliente>());
}
public DireccionController(IDireccionService DireccionService, IClienteService ClienteService)
{
_DireccionService = DireccionService;
_ClienteService = ClienteService;
}
protected void DataManagerBase(IClienteService repositorio, BaseControl control)
{
if (repositorio == null)
throw new ArgumentNullException("repositorio");
if (control == null)
throw new ArgumentNullException("control");
_service = repositorio;
Controle = control;
RefreshAll();
}
public ClienteAppService(IClienteService clieteServeService)
{
_clieteService = clieteServeService;
}
