public IHttpActionResult ProductoDescuentoCreate(ProductoDescuentoModel productoDescuentoModel)
{
try
{
if (UsuarioModel.Instance.rol != Rol.ADMINISTRADOR && UsuarioModel.Instance.rol != Rol.DEV)
{
return(Json(Mensaje <Domain.Entities.Producto.ProductoDescuento> .MensajeJson(Constants.IS_ERROR, "No esta autorizado para realizar esta operacion", Constants.NO_AUTH)));
}
if (productoDescuentoModel.ProductoDescuento == null)
{
return(Json(Mensaje <Domain.Entities.Producto.ProductoDescuento> .MensajeJson(Constants.IS_ERROR, "Objecto no puede estar vacio", Constants.PRODUCTO_DESCUENTO_FAIL)));
}
var ProductoDescuento = productoDescuentoModel._repository.FindBy(x => x.Producto_Id == productoDescuentoModel.ProductoDescuento.Producto_Id && x.Descuento_Id == productoDescuentoModel.ProductoDescuento.Descuento_Id);
if (ProductoDescuento != null)
{
return(Json(Mensaje <Domain.Entities.Producto.ProductoDescuento> .MensajeJson(Constants.IS_ERROR, "Producto Descuento ya existe", Constants.PRODUCTO_DESCUENTO_FAIL)));
}
var pd = productoDescuentoModel.Create(BuilderFactories.ProductoDescuento(productoDescuentoModel.ProductoDescuento.Producto_Id, productoDescuentoModel.ProductoDescuento.Descuento_Id, productoDescuentoModel.ProductoDescuento.EstadoDescuento));
if (pd == null)
{
return(Json(Mensaje <Domain.Entities.Producto.ProductoDescuento> .MensajeJson(Constants.IS_ERROR, "Producto Descuento no pudo crearse", Constants.PRODUCTO_DESCUENTO_FAIL)));
}
return(Json(Mensaje <Domain.Entities.Producto.ProductoDescuento> .MensajeJson(Constants.NO_ERROR, "Producto Descuento creado con exito", Constants.PRODUCTO_DESCUENTO_SUCCES)));
}
catch (Exception e)
{
return(Json(Mensaje <Domain.Entities.Producto.ProductoDescuento> .MensajeJson(Constants.IS_ERROR, e.Message, Constants.PRODUCTO_DESCUENTO_FAIL)));
}
}
public ServiceResponse Create(ServicioUsuarioRequest request)
{
var usuario = Get(request);
if (usuario == null)
{
var buildUser = BuilderFactories.Usuario(request.Username, request.Password, request.Activo, request.Rol);
usuario = _repository.Add(buildUser);
if (_unitOfWork.Commit() == 1)
{
return(new ServiceResponse()
{
Mensaje = "Usuario Creado con exito",
Status = true,
Id = usuario.Id
});
}
else
{
return(new ServiceResponse()
{
Mensaje = "Usuario no pudo Crearse", Status = false
});
}
}
else
{
return(new ServiceResponse()
{
Mensaje = "Usuario Ya existe", Status = false
});
}
}
public IHttpActionResult DescuentoCreate(DescuentoModel descuentoModel)
{
try
{
if (UsuarioModel.Instance.rol != Rol.ADMINISTRADOR && UsuarioModel.Instance.rol != Rol.DEV)
{
return(Json(Mensaje <Domain.Entities.Producto.Descuento> .MensajeJson(Constants.IS_ERROR, "No esta autorizado para realizar esta operacion", Constants.NO_AUTH)));
}
if (descuentoModel.Descuento == null)
{
return(Json(Mensaje <Domain.Entities.Producto.Descuento> .MensajeJson(Constants.IS_ERROR, "Objecto no puede estar vacio", Constants.DESCUENTO_FAIL)));
}
var descuento = descuentoModel.Create(BuilderFactories.Descuento(descuentoModel.Descuento.TipoDescuento, descuentoModel.Descuento.Acomulable, descuentoModel.Descuento.FechaYHoraInicio, descuentoModel.Descuento.FechaYHoraTerminación, descuentoModel.Descuento.Descu));
if (descuento == null)
{
return(Json(Mensaje <Domain.Entities.Producto.Descuento> .MensajeJson(Constants.IS_ERROR, "Descuento no pudo crearse", Constants.DESCUENTO_FAIL)));
}
return(Json(Mensaje <Domain.Entities.Producto.Descuento> .MensajeJson(Constants.NO_ERROR, "Descuento Creado con exito", Constants.DESCUENTO_SUCCES)));
}
catch (Exception e)
{
return(Json(Mensaje <Domain.Entities.Producto.Descuento> .MensajeJson(Constants.IS_ERROR, e.Message, Constants.DESCUENTO_FAIL)));
}
}
public ServiceResponse Create(ServicioMetodoPagoRequest request)
{
var metodoPago = Get(request);
if (metodoPago != null)
{
return(new ServiceResponse
{
Mensaje = "Metodo de pago ya existe",
Status = false
});
}
var buildMetodoPago = BuilderFactories.ClienteMetodoDePago(request.Cliente_Id, request.Activo, request.Saldo, request.CreditCard.Type, request.CreditCard.CardNumber, request.CreditCard.SecurityNumber, request.CreditCard.OwnerName, request.CreditCard.ExpirationDate);
metodoPago = _repository.Add(buildMetodoPago);
if (_unitOfWork.Commit() == 1)
{
return(new ServiceResponse
{
Id = metodoPago.Id,
Mensaje = "Metodo de pago creado con exito",
Status = true
});
}
else
{
return(new ServiceResponse
{
Mensaje = "Metodo no pudo crearse",
Status = false
});
}
}
public IHttpActionResult ProductoCreate(ProductoModel productoModel)
{
try
{
if (UsuarioModel.Instance.rol != Rol.ADMINISTRADOR && UsuarioModel.Instance.rol != Rol.DEV)
{
return(Json(Mensaje <Domain.Entities.Producto.Producto> .MensajeJson(Constants.IS_ERROR, "No esta autorizado para realizar esta operacion", Constants.NO_AUTH)));
}
if (productoModel.Producto == null)
{
return(Json(Mensaje <Domain.Entities.Producto.Producto> .MensajeJson(Constants.IS_ERROR, "Objecto no puede estar vacio", Constants.PRODUCTO_FAIL)));
}
if (productoModel._repository.FindBy(x => x.PrecioVenta == productoModel.Producto.PrecioVenta && x.Nombre == productoModel.Producto.Nombre).Count() > 0)
{
return(Json(Mensaje <Domain.Entities.Producto.Producto> .MensajeJson(Constants.IS_ERROR, "Producto ya existe", Constants.PRODUCTO_FAIL)));
}
var producto = productoModel.Create(BuilderFactories.Producto(productoModel.Producto.Nombre, productoModel.Producto.Descripción, productoModel.Producto.Imagen, productoModel.Producto.PrecioCompra, productoModel.Producto.PrecioVenta, productoModel.Producto.CantidadProducto, productoModel.Producto.Categoria_Id));
if (producto == null)
{
return(Json(Mensaje <Domain.Entities.Producto.Producto> .MensajeJson(Constants.IS_ERROR, "Producto no pudo crearse", Constants.PRODUCTO_FAIL)));
}
return(Json(Mensaje <Domain.Entities.Producto.Producto> .MensajeJson(Constants.NO_ERROR, "Producto Creado con exito", Constants.PRODUCTO_SUCCES)));
}
catch (Exception e)
{
return(Json(Mensaje <Domain.Entities.Producto.Producto> .MensajeJson(Constants.IS_ERROR, e.Message, Constants.PRODUCTO_FAIL)));
}
}
public void EditFailsYSuccessTest()
{
if (usuario_id == 0)
{
usuario_id = new ServicioUsuarioTest.ServicioUsuarioTest().ServicioUsuario.GetId(new ServicioUsuarioRequest {
Username = "******"
});
}
var nombre = new Nombre("carlos", "andres", "castilla", "garcia");
var FactoryCliente = BuilderFactories.Cliente("1063969856", nombre, "*****@*****.**", usuario_id);
var cliente = new ServicioClienteRequest()
{
Documento = FactoryCliente.Documento,
Email = FactoryCliente.Email,
Nombre = FactoryCliente.Nombre,
Usuario_Id = 100
};
var responseCliente = ServicioCliente.Edit(cliente);
Assert.AreEqual(responseCliente.Mensaje, "Cliente no existe");
cliente.Usuario_Id = usuario_id;
responseCliente = ServicioCliente.Edit(cliente);
Assert.AreEqual(responseCliente.Mensaje, "Documento ya existe");
cliente.Documento = "1063969857";
responseCliente = ServicioCliente.Edit(cliente);
Assert.AreEqual(responseCliente.Mensaje, "Email ya existe");
cliente.Email = "*****@*****.**";
responseCliente = ServicioCliente.Edit(cliente);
Assert.AreEqual(responseCliente.Mensaje, "Cliente Modificado con exito");
}
public IHttpActionResult CategoriaCreate(CategoriaModel categoriaModel)
{
if (UsuarioModel.Instance.rol != Rol.ADMINISTRADOR && UsuarioModel.Instance.rol != Rol.DEV)
{
return(Json(Mensaje <Domain.Entities.Producto.Categoria> .MensajeJson(Constants.IS_ERROR, "No esta autorizado para realizar esta operacion", Constants.NO_AUTH)));
}
if (categoriaModel.Categoria == null)
{
return(Json(Mensaje <Domain.Entities.Producto.Categoria> .MensajeJson(Constants.IS_ERROR, "Objecto no puede estar vacio", Constants.CATEGORIA_FAIL)));
}
var categoria = categoriaModel.GetByName(categoriaModel.Categoria.Nombre);
if (categoria == null)
{
var c = categoriaModel.Create(BuilderFactories.Categoria(categoriaModel.Categoria.Nombre, categoriaModel.Categoria.Descripción, (categoriaModel.Categoria.FechaCreacion.Year < DateTime.Now.Year) ? DateTime.Now : categoriaModel.Categoria.FechaCreacion));
if (c != null)
{
return(Json(Mensaje <Domain.Entities.Producto.Categoria> .MensajeJson(Constants.NO_ERROR, "Categoria creada con exito", Constants.CATEGORIA_SUCCES)));
}
else
{
return(Json(Mensaje <Domain.Entities.Producto.Categoria> .MensajeJson(Constants.IS_ERROR, "Error al crear la categoria", Constants.CATEGORIA_FAIL)));
}
}
else
{
return(Json(Mensaje <Domain.Entities.Producto.Categoria> .MensajeJson(Constants.IS_ERROR, "Categoria ya existe", Constants.CATEGORIA_FAIL)));
}
}
public ServiceResponse Create(ServicioCompraClienteRequest request)
{
if (request == null)
{
return(new ServiceResponse
{
Mensaje = "Compra Cliente No puede estar vacio",
Status = false
});
}
var CompraCliente = base.Create(BuilderFactories.CompraCliente(request.Producto_Id, request.Compra_Id, request.Cantidad, request.EstadoClienteArticulo));
if (CompraCliente == null)
{
return(new ServiceResponse
{
Mensaje = "Compra Cliente No Pudo Crearse",
Status = false
});
}
return(new ServiceResponse
{
Id = CompraCliente.Id,
Mensaje = "Compra Cliente creada con exito",
Status = true
});
}
public ServiceResponse Create(ServicioCompraRequest request)
{
if (request == null)
{
return(new ServiceResponse
{
Mensaje = "Compra no debe estar vacia",
Status = false
});
}
var compra = base.Create(BuilderFactories.Compra(request.Cliente_Id, request.FechaCompra));
if (compra == null)
{
return(new ServiceResponse
{
Mensaje = "Compra no pudo crearse",
Status = false
});
}
return(new ServiceResponse
{
Id = compra.Id,
Mensaje = "Compra Creada con exito",
Status = true
});
}
public void Initialize()
{
compra = BuilderFactories.Compra(1, DateTime.Now);
compra.Id = 1;
compra.Cliente = new ClienteTest().cliente;
compra.CompraClientes = new List <CompraCliente>()
{
new CompraClienteTest().compraCliente
};
compra.CompraClientes.FirstOrDefault().Producto = new ProductoTest().producto;
compra.CompraClientes.FirstOrDefault().Producto.ProductoDescuentos = new List <ProductoDescuento>()
{
new ProductoDescuentoTest().productoDescuento
};
compra.CompraClientes.FirstOrDefault().Producto.ProductoDescuentos.FirstOrDefault().Descuento = new DescuentoTest().descuento;
compra.ComprobanteDePagos = new List <ComprobanteDePago>()
{
BuilderFactories.ComprobanteDePago(EstadoDePago.EN_ESPERA, compra.ObtenerTotal(), compra.ObtenerSubTotal(), MedioPago.EFECTIVO, 0, DateTime.Now, compra.ObtenerDescuento(), 1)
};
compra.CompraEnvios = new List <CompraEnvio>()
{
new CompraEnvioTest().compraEnvio
};
compra.CompraEnvios.FirstOrDefault().Id = 1;
compra.CompraEnvios.FirstOrDefault().Compra = compra;
compra.CompraEnvios.FirstOrDefault().CompraEnvioProductos = new List <CompraEnvioProducto>
{
new CompraEnvioProducto(1, 1, 1, DateTime.Now, Enum.EstadoDeEnvioProducto.NO_ENVIADO)
};
compra.CompraEnvios.FirstOrDefault().EstadoDeEnvio = Enum.EstadoDeEnvio.EN_VERIFICACIÓN;
}
public IHttpActionResult Crear(UsuarioModel usuario)
{
if (usuario.Usuario == null)
{
return(Json(Mensaje <Domain.Entities.Cliente.Usuario> .MensajeJson(Constants.IS_ERROR, "Objecto no puede estar vacio", Constants.USER_FAIL)));
}
try
{
var factoryUser = BuilderFactories.Usuario(usuario.Usuario.Username, usuario.Usuario.Password, true, Rol.INVITADO);
var response = usuario.ServicioUsuario.Create(new ServicioUsuarioRequest {
Username = factoryUser.Username, Password = factoryUser.Password, Rol = Rol.CLIENTE, Activo = true
});
if (!response.Status)
{
return(Json(Mensaje <Domain.Entities.Cliente.Usuario> .MensajeJson(Constants.IS_ERROR, response.Mensaje, Constants.USER_FAIL)));
}
return(Json(Mensaje <Domain.Entities.Cliente.Usuario> .MensajeJson(Constants.NO_ERROR, response.Mensaje, Constants.USER_SUCCESS)));
}
catch (Exception e)
{
return(Json(Mensaje <Domain.Entities.Cliente.Usuario> .MensajeJson(Constants.IS_ERROR, e.Message, Constants.USER_INVALID)));
}
}
public void Initialize()
{
client = new RestClient("http://localhost/JsonTest/cliente/");
var nombre = new Nombre("string", "string", "string", "string");
Cliente = BuilderFactories.Cliente("string", nombre, "string", 1);
Cliente.Id = 1;
}
public ComputationFactory(GameData gameData)
{
_builderFactories = new Lazy <Task <IBuilderFactories> >(
() => BuilderFactories.CreateAsync(gameData));
_parser = new Lazy <Task <IParser> >(
() => Parser <ParsingStep> .CreateAsync(gameData, _builderFactories.Value,
ParsingData.CreateAsync(gameData, _builderFactories.Value)));
}
private static SupportSkillParser CreateSut(
SkillDefinition activeSkillDefinition, SkillDefinition supportSkillDefinition,
UntranslatedStatParserFactory statParserFactory)
{
var skillDefinitions = new SkillDefinitions(new[] { activeSkillDefinition, supportSkillDefinition });
var builderFactories = new BuilderFactories(skillDefinitions);
return(new SupportSkillParser(skillDefinitions, builderFactories, statParserFactory));
}
public void Initialize()
{
compraCliente = BuilderFactories.CompraCliente(
1,
1,
10,
Enum.EstadoClienteArticulo.NO_PAGADO);
compraCliente.Id = 1;
}
public ComputationFactory(GameData gameData)
{
_calculator = new Lazy <ICalculator>(Calculator.Create);
_builderFactories = new Lazy <Task <IBuilderFactories> >(
() => BuilderFactories.CreateAsync(gameData));
_parser = new Lazy <Task <IParser> >(
async() => await Parser <ParsingStep> .CreateAsync(gameData, _builderFactories.Value,
ParsingData.CreateAsync(gameData, _builderFactories.Value)));
}
public IHttpActionResult Edit(ClienteModel clienteModel)
{
if (usuario.id == 0)
{
throw new ArgumentException(Constants.NO_AUTH);
}
if (clienteModel.Cliente == null)
{
return(Json(Mensaje <Domain.Entities.Cliente.Cliente> .MensajeJson(Constants.IS_ERROR, "Objecto no puede estar vacio", Constants.CLIENT_FAIL)));
}
var FactoryCliente = BuilderFactories.Cliente(clienteModel.Cliente.Documento, clienteModel.Cliente.Nombre, clienteModel.Cliente.Email, usuario.id);
var responseCliente = clienteModel.ServicioCliente.Edit(new ServicioClienteRequest()
{
Documento = FactoryCliente.Documento,
Email = FactoryCliente.Email,
Nombre = FactoryCliente.Nombre,
Usuario_Id = usuario.id,
});
if (clienteModel.Cliente.Telefónos != null)
{
clienteModel.Cliente.Telefónos.ToList().ForEach(x =>
{
clienteModel.ServicioTelefóno.Edit(new ServicioTelefónoRequest
{
Cliente_Id = responseCliente.Id,
Número = x.Número,
TipoTelefono = x.TipoTelefono,
Id = x.Id
});
});
}
if (clienteModel.Cliente.Direcciónes != null)
{
clienteModel.Cliente.Direcciónes.ToList().ForEach(x =>
{
clienteModel.ServicioDirección.Edit(new ServicioDireccíonRequest
{
Cliente_Id = responseCliente.Id,
Barrio = x.Barrio,
Direccion = x.Direccion,
Municipio = x.Municipio,
CodigoPostal = x.CodigoPostal,
Id = x.Id
});
});
}
return(Json(Mensaje <Domain.Entities.Cliente.Cliente> .MensajeJson(Constants.NO_ERROR, responseCliente.Mensaje, Constants.CLIENT_SUCCESS)));
}
public ServiceResponse Create(ServicioClienteRequest request)
{
var cliente = Get(request);
if (cliente == null)
{
if (_repository.FindBy(x => x.Usuario_Id == request.Usuario_Id).FirstOrDefault() != null)
{
return(new ServiceResponse()
{
Mensaje = "Cliente ya existe", Status = false
});
}
if (_repository.FindBy(x => x.Documento == request.Documento).FirstOrDefault() != null)
{
return(new ServiceResponse()
{
Mensaje = "Documento ya existe", Status = false
});
}
if (_repository.FindBy(x => x.Email == request.Email).FirstOrDefault() != null)
{
return(new ServiceResponse()
{
Mensaje = "Email ya existe", Status = false
});
}
var builderCLient = BuilderFactories.Cliente(request.Documento, request.Nombre, request.Email, request.Usuario_Id);
cliente = _repository.Add(builderCLient);
if (_unitOfWork.Commit() == 1)
{
return(new ServiceResponse()
{
Mensaje = "Cliente creado exito", Status = true, Id = cliente.Id
});
}
else
{
return(new ServiceResponse()
{
Mensaje = "No se pudo crear cliente", Status = false
});
}
}
return(new ServiceResponse()
{
Mensaje = "Cliente ya existe", Status = false
});
}
public void CreateSuccessTest()
{
var factoryUser = BuilderFactories.Usuario("test", "toor", true, Rol.CLIENTE);
var response = ServicioUsuario.Create(new ServicioUsuarioRequest {
Username = factoryUser.Username,
Password = factoryUser.Password,
Activo = factoryUser.Activo,
Rol = factoryUser.Rol
});
Console.WriteLine(response.Mensaje);
}
public void CreateFailsTest1()
{
var factoryUser = BuilderFactories.Usuario("zeros", "toor", true, Rol.CLIENTE);
var response = ServicioUsuario.Create(new ServicioUsuarioRequest
{
Username = factoryUser.Username,
Password = factoryUser.Password,
Activo = factoryUser.Activo,
Rol = factoryUser.Rol
});
Assert.AreEqual(response.Status, false);
}
public IHttpActionResult ProductoEdit(ProductoModel productoModel)
{
try
{
if (UsuarioModel.Instance.rol != Rol.ADMINISTRADOR && UsuarioModel.Instance.rol != Rol.DEV)
{
return(Json(Mensaje <Domain.Entities.Producto.Producto> .MensajeJson(Constants.IS_ERROR, "No esta autorizado para realizar esta operacion", Constants.NO_AUTH)));
}
if (productoModel.Producto == null)
{
return(Json(Mensaje <Domain.Entities.Producto.Producto> .MensajeJson(Constants.IS_ERROR, "Objecto no puede estar vacio", Constants.PRODUCTO_FAIL)));
}
if (productoModel.Producto.PrecioCompra > productoModel.Producto.PrecioVenta)
{
return(Json(Mensaje <Domain.Entities.Producto.Producto> .MensajeJson(Constants.IS_ERROR, "Precio de compra no puede mayor al precio de venta", Constants.PRODUCTO_FAIL)));
}
var producto = productoModel._repository.FindBy(x => x.Id == productoModel.Producto.Id).FirstOrDefault();
if (producto == null)
{
return(Json(Mensaje <Domain.Entities.Producto.Producto> .MensajeJson(Constants.IS_ERROR, "Producto no existe", Constants.PRODUCTO_FAIL)));
}
var factoryProducto = BuilderFactories.Producto(productoModel.Producto.Nombre, productoModel.Producto.Descripción, productoModel.Producto.Imagen, productoModel.Producto.PrecioCompra, productoModel.Producto.PrecioVenta, productoModel.Producto.CantidadProducto, productoModel.Producto.Categoria_Id);
producto.Nombre = factoryProducto.Nombre;
producto.Descripción = factoryProducto.Descripción;
producto.Imagen = factoryProducto.Imagen;
producto.PrecioCompra = factoryProducto.PrecioCompra;
producto.PrecioVenta = factoryProducto.PrecioVenta;
producto.CantidadProducto = factoryProducto.CantidadProducto;
producto.Categoria_Id = factoryProducto.Categoria_Id;
if (!productoModel.Update(producto))
{
return(Json(Mensaje <Domain.Entities.Producto.Producto> .MensajeJson(Constants.IS_ERROR, "Producto no pudo Modificarse", Constants.PRODUCTO_FAIL)));
}
return(Json(Mensaje <Domain.Entities.Producto.Producto> .MensajeJson(Constants.NO_ERROR, "Producto Modificado con exito", Constants.PRODUCTO_SUCCES)));
}
catch (Exception e)
{
return(Json(Mensaje <Domain.Entities.Producto.Producto> .MensajeJson(Constants.IS_ERROR, e.Message, Constants.PRODUCTO_FAIL)));
}
}
public CompraModel Comprar(Compra compra)
{
if (compra == null || compra.CompraClientes == null)
{
return(null);
}
Instance.Compra = compra;
var response = Instance.ServicioCompra.Create(new ServicioCompraRequest
{
Cliente_Id = compra.Cliente_Id,
FechaCompra = compra.FechaCompra.Year < DateTime.Now.Year ? DateTime.Now : compra.FechaCompra,
});
if (response.Status)
{
Instance.Compra.CompraClientes = compra.CompraClientes;
Instance.Compra.CompraClientes.ToList().ForEach(x =>
{
ServicioCompraCliente.Create(new ServicioCompraClienteRequest
{
Cantidad = x.Cantidad,
Compra_Id = response.Id,
Producto_Id = x.Producto_Id,
EstadoClienteArticulo = x.EstadoClienteArticulo
});
x.Producto = ProductoModel.ProductoModel.Instance.Find(x.Producto_Id);
x.Producto.ProductoDescuentos = ProductoDescuentoModel.Instance._repository.FindBy(y => y.Producto_Id == x.Producto_Id);
x.Producto.ProductoDescuentos.ToList().ForEach(z =>
{
z.Descuento = DescuentoModel.Instance.Find(z.Descuento_Id);
});
x.Compra_Id = response.Id;
});
Instance.Compra.Id = response.Id;
if (compra.ComprobanteDePagos == null)
{
compra.ComprobanteDePagos = new List <ComprobanteDePago>()
{
BuilderFactories.ComprobanteDePago(EstadoDePago.EN_ESPERA, Instance.Compra.ObtenerTotal(), Instance.Compra.ObtenerSubTotal(), MedioPago.EFECTIVO, 0, DateTime.Now, Instance.Compra.ObtenerDescuento(), response.Id)
};
}
Instance.Compra.ComprobanteDePagos = compra.ComprobanteDePagos;
ComprobanteDePagoModel.Instance.Create(Instance.Compra.ComprobanteDePagos.FirstOrDefault());
}
return(Instance);
}
public ServiceResponse Create(ServicioDireccíonRequest request)
{
var dirección = _repository.FindBy(x => x.Cliente_Id == request.Cliente_Id && x.Barrio == request.Barrio && x.Direccion == request.Direccion).FirstOrDefault();
if (dirección != null)
{
return(new ServiceResponse()
{
Mensaje = "Dirección ya registrado", Status = false
});
}
if (request.Direcciónes != null)
{
dirección = _repository.AddRange(request.Direcciónes.ToList()).FirstOrDefault();
}
if (request.Municipio_Id != 0)
{
dirección = _repository.Add(BuilderFactories.Dirección(request.Barrio, request.Direccion, request.CodigoPostal, request.Municipio_Id, request.Cliente_Id));
}
if (dirección == null)
{
return(new ServiceResponse()
{
Mensaje = "Usuario fue Creado con exito, (Error al registrar Dirección)", Status = false
});
}
if (_unitOfWork.Commit() == 1)
{
return(new ServiceResponse()
{
Mensaje = "Usuario fue Creado con exito, (Dirección(es) creada(s) con exito)", Status = true
});
}
else
{
return(new ServiceResponse()
{
Mensaje = "Usuario fue Creado con exito, (No se pudo registrar las/la Dirección(es)", Status = false
});
}
}
public IHttpActionResult DescuentoEdit(DescuentoModel descuentoModel)
{
try
{
if (UsuarioModel.Instance.rol != Rol.ADMINISTRADOR && UsuarioModel.Instance.rol != Rol.DEV)
{
return(Json(Mensaje <Domain.Entities.Producto.Descuento> .MensajeJson(Constants.IS_ERROR, "No esta autorizado para realizar esta operacion", Constants.NO_AUTH)));
}
if (descuentoModel.Descuento == null)
{
return(Json(Mensaje <Domain.Entities.Producto.Descuento> .MensajeJson(Constants.IS_ERROR, "Objecto no puede estar vacio", Constants.DESCUENTO_FAIL)));
}
var descuento = descuentoModel.Find(descuentoModel.Descuento.Id);
if (descuento == null)
{
return(Json(Mensaje <Domain.Entities.Producto.Descuento> .MensajeJson(Constants.IS_ERROR, "No existe Descuento", Constants.DESCUENTO_FAIL)));
}
//si esta mal arroja una excepcion
var factoryDescuento = BuilderFactories.Descuento(descuentoModel.Descuento.TipoDescuento, descuentoModel.Descuento.Acomulable, descuentoModel.Descuento.FechaYHoraInicio, descuentoModel.Descuento.FechaYHoraTerminación, descuentoModel.Descuento.Descu);
descuento.Descu = factoryDescuento.Descu;
descuento.TipoDescuento = factoryDescuento.TipoDescuento;
descuento.Acomulable = factoryDescuento.Acomulable;
descuento.FechaYHoraInicio = factoryDescuento.FechaYHoraInicio;
descuento.FechaYHoraTerminación = factoryDescuento.FechaYHoraTerminación;
if (!descuentoModel.Update(descuento))
{
return(Json(Mensaje <Domain.Entities.Producto.Descuento> .MensajeJson(Constants.IS_ERROR, "Descuento no pudo Modificarse", Constants.DESCUENTO_FAIL)));
}
return(Json(Mensaje <Domain.Entities.Producto.Descuento> .MensajeJson(Constants.NO_ERROR, "Descuento Modificado con exito", Constants.DESCUENTO_SUCCES)));
}
catch (Exception e)
{
return(Json(Mensaje <Domain.Entities.Producto.Descuento> .MensajeJson(Constants.IS_ERROR, e.Message, Constants.DESCUENTO_FAIL)));
}
}
public IHttpActionResult CategoriaEdit(CategoriaModel categoriaModel)
{
if (UsuarioModel.Instance.rol != Rol.ADMINISTRADOR && UsuarioModel.Instance.rol != Rol.DEV)
{
return(Json(Mensaje <Domain.Entities.Producto.Categoria> .MensajeJson(Constants.IS_ERROR, "No esta autorizado para realizar esta operacion", Constants.NO_AUTH)));
}
if (categoriaModel.Categoria == null)
{
return(Json(Mensaje <Domain.Entities.Producto.Categoria> .MensajeJson(Constants.IS_ERROR, "Objecto no puede estar vacio", Constants.CATEGORIA_FAIL)));
}
if (categoriaModel.ServicioProducto.GetExiste(new ServicioProductoRequest {
Id = categoriaModel.Categoria.Id, Nombre = categoriaModel.Categoria.Nombre
}))
{
return(Json(Mensaje <Domain.Entities.Producto.Categoria> .MensajeJson(Constants.IS_ERROR, "Nombre Categoria ya existe", Constants.CATEGORIA_FAIL)));
}
var categoria = categoriaModel.Find(categoriaModel.Categoria.Id);
if (categoria != null)
{
var factoryCategoria = BuilderFactories.Categoria(categoriaModel.Categoria.Nombre, categoriaModel.Categoria.Descripción, (categoriaModel.Categoria.FechaCreacion.Year < DateTime.Now.Year) ? DateTime.Now : categoriaModel.Categoria.FechaCreacion);
categoria.Nombre = factoryCategoria.Nombre;
categoria.Descripción = factoryCategoria.Descripción;
if (categoriaModel.Update(categoria))
{
return(Json(Mensaje <Domain.Entities.Producto.Categoria> .MensajeJson(Constants.NO_ERROR, "Categoria Modificada con exito", Constants.CATEGORIA_SUCCES)));
}
else
{
return(Json(Mensaje <Domain.Entities.Producto.Categoria> .MensajeJson(Constants.IS_ERROR, "Error al modificar la categoria", Constants.CATEGORIA_FAIL)));
}
}
else
{
return(Json(Mensaje <Domain.Entities.Producto.Categoria> .MensajeJson(Constants.IS_ERROR, "Categoria no existe", Constants.CATEGORIA_FAIL)));
}
}
public void CreateFailsYSuccessTest()
{
new ServicioUsuarioTest.ServicioUsuarioTest().ServicioUsuario.Delete(new ServicioUsuarioTest.ServicioUsuarioTest().ServicioUsuario._repository.FindBy(x => x.Username == "test").LastOrDefault());
new ServicioUsuarioTest.ServicioUsuarioTest().CreateSuccessTest();
var nombre = new Nombre("carlos", "andres", "castilla", "garcia");
var FactoryCliente = BuilderFactories.Cliente("1063969856", nombre, "*****@*****.**", 1);
var cliente = new ServicioClienteRequest()
{
Documento = FactoryCliente.Documento,
Email = FactoryCliente.Email,
Nombre = FactoryCliente.Nombre,
Usuario_Id = 1
};
var responseCliente = ServicioCliente.Create(cliente);
Assert.AreEqual(responseCliente.Mensaje, "Cliente ya existe");
if (usuario_id == 0)
{
usuario_id = new ServicioUsuarioTest.ServicioUsuarioTest().ServicioUsuario.GetId(new ServicioUsuarioRequest {
Username = "******"
});
}
cliente.Usuario_Id = usuario_id;
responseCliente = ServicioCliente.Create(cliente);
Assert.AreEqual(responseCliente.Mensaje, "Documento ya existe");
cliente.Documento = "1063969858";
responseCliente = ServicioCliente.Create(cliente);
Assert.AreEqual(responseCliente.Mensaje, "Email ya existe");
cliente.Email = "*****@*****.**";
responseCliente = ServicioCliente.Create(cliente);
Assert.AreEqual(responseCliente.Mensaje, "Cliente creado exito");
usuario_id = new ServicioUsuarioTest.ServicioUsuarioTest().ServicioUsuario.GetId(new ServicioUsuarioRequest {
Username = "******"
});
}
public IHttpActionResult CategoriaEdit(CategoriaModel categoriaModel)
{
if (UsuarioModel.Instance.rol != Rol.ADMINISTRADOR && UsuarioModel.Instance.rol != Rol.DEV)
{
return(Json(Mensaje <Categoria> .MensajeJson(Constants.IS_ERROR, "No esta autorizado para realizar esta operacion", Constants.NO_AUTH)));
}
if (categoriaModel.Categoria == null)
{
return(Json(Mensaje <Categoria> .MensajeJson(Constants.IS_ERROR, "Objecto no puede estar vacio", Constants.CATEGORIA_FAIL)));
}
var categoria = categoriaModel._repository.FindBy(x => x.Nombre == categoriaModel.Categoria.Nombre && x.Id != categoriaModel.Categoria.Id).FirstOrDefault();
if (categoria != null)
{
return(Json(Mensaje <Categoria> .MensajeJson(Constants.IS_ERROR, "Nombre Categoria ya existe", Constants.CATEGORIA_FAIL)));
}
categoria = categoriaModel._repository.FindBy(x => x.Id == categoriaModel.Categoria.Id).FirstOrDefault();
if (categoria != null)
{
var factoryCategoria = BuilderFactories.Categoria(categoriaModel.Categoria.Nombre, categoriaModel.Categoria.Descripción, (categoriaModel.Categoria.FechaCreacion.Year < DateTime.Now.Year) ? DateTime.Now : categoriaModel.Categoria.FechaCreacion);
categoria.Nombre = factoryCategoria.Nombre;
categoria.Descripción = factoryCategoria.Descripción;
if (categoriaModel.Update(categoria))
{
return(Json(Mensaje <Categoria> .MensajeJson(Constants.NO_ERROR, "Categoria Modificada con exito", Constants.CATEGORIA_SUCCES)));
}
else
{
return(Json(Mensaje <Categoria> .MensajeJson(Constants.IS_ERROR, "Error al modificar la categoria", Constants.CATEGORIA_FAIL)));
}
}
else
{
return(Json(Mensaje <Categoria> .MensajeJson(Constants.IS_ERROR, "Categoria no existe", Constants.CATEGORIA_FAIL)));
}
}
public IHttpActionResult Authenticar(UsuarioModel usuario)
{
if (usuario.Usuario == null)
{
return(Json(Mensaje <Domain.Entities.Cliente.Usuario> .MensajeJson(Constants.IS_ERROR, "Objecto no puede estar vacio", Constants.USER_FAIL)));
}
if (usuario == null || usuario.Usuario.Username == null || usuario.Usuario.Password == null)
{
return(Json(Mensaje <Domain.Entities.Cliente.Usuario> .MensajeJson(Constants.IS_ERROR, Constants.USER_INVALID, Constants.USER_FAIL)));
}
try
{
var factoryUser = BuilderFactories.Usuario(usuario.Usuario.Username, usuario.Usuario.Password, true, Domain.Enum.Rol.INVITADO);
var user = usuario.ServicioUsuario.Autenticar(new ServicioUsuarioRequest()
{
Username = factoryUser.Username, Password = factoryUser.Password
});
if (user == null)
{
return(Unauthorized());
}
if (user.Activo == false)
{
return(Json(Mensaje <Domain.Entities.Cliente.Usuario> .MensajeJson(Constants.IS_ERROR, Constants.USER_INACTIVE, Constants.USER_FAIL)));
}
var token = TokenGenerator.GenerateTokenJwt(usuario.Usuario.Username);
return(Ok((Mensaje <Domain.Entities.Cliente.Cliente> .MensajeJson(Constants.NO_ERROR, token, Constants.USER_SUCCESS, ClienteModel.Instance._repository.FindBy(x => x.Usuario_Id == user.Id).FirstOrDefault()))));
}
catch (Exception e)
{
return(Json(Mensaje <Domain.Entities.Cliente.Usuario> .MensajeJson(Constants.IS_ERROR, e.Message, Constants.USER_INVALID)));
}
}
public ServiceResponse Create(ServicioTelefónoRequest request)
{
var telefóno = _repository.FindBy(x => x.Cliente_Id == request.Cliente_Id && x.Número == request.Número).FirstOrDefault();
if (telefóno != null)
{
return(new ServiceResponse()
{
Mensaje = "Telefono ya registrado", Status = false
});
}
if (request.Número != null)
{
telefóno = _repository.Add(BuilderFactories.Telefóno(request.Número, request.TipoTelefono, request.Cliente_Id));
}
if (telefóno == null)
{
return(new ServiceResponse()
{
Mensaje = "Usuario fue Creado con exito, (Error al registrar telefono)", Status = false
});
}
if (_unitOfWork.Commit() == 1)
{
return(new ServiceResponse()
{
Mensaje = "Usuario fue Creado con exito, (Telefono(s) creado(s) con exito)", Status = true
});
}
else
{
return(new ServiceResponse()
{
Mensaje = "Usuario fue Creado con exito, (No se pudo registrar los/el telefono)", Status = false
});
}
}
public void Initialize()
{
var nombre = new Nombre("carlos", "andres", "castilla", "garcia");
//inicializo cliente
cliente = BuilderFactories.Cliente("1063969856", nombre, "*****@*****.**", 1);
cliente.Id = 1;
//inicializo usuario
cliente.Usuario = BuilderFactories.Usuario("zeros", "toor", true, Enum.Rol.ADMINISTRADOR);
cliente.Usuario.Id = 1;
cliente.Telefónos = new List <Telefóno>
{
BuilderFactories.Telefóno("3043541475", Enum.TipoTelefono.CELULAR, 1)
};
cliente.Telefónos.FirstOrDefault().Id = 1;
cliente.Direcciónes = new List <Dirección>
{
BuilderFactories.Dirección("El recreo", "cr 22 # 16-76", "000", 1, 1)
};
cliente.Direcciónes.FirstOrDefault().Id = 1;
cliente.Direcciónes.FirstOrDefault().Municipio = new Municipio("Bosconia", 1)
{
Departamento = new Departamento("Cesar", 1),
};
cliente.Direcciónes.FirstOrDefault().Municipio.Departamento.País = new País("Colombia", Enum.Continente.AMÉRICA_SUR);
cliente.ClienteMetodoDePagos = new List <ClienteMetodoDePago>
{
BuilderFactories.ClienteMetodoDePago(1, true, 10000, Enum.CreditCardType.Visa, "5269736513905509", "000", "carlos ", new DateTime(2019, 10, 20))
};
cliente.ClienteMetodoDePagos.FirstOrDefault().Id = 1;
cliente.ClienteMetodoDePagos.FirstOrDefault().Cliente = null;
}
