public IHttpActionResult Get(int id)
{
Importacion impor = null;
try
{
using (MiContextoContext db = new MiContextoContext())
{
impor = db.importaciones.Include(i => i.Producto)
.Include(i => i.Producto.Cliente)
.Where(i => i.Id == id)
.FirstOrDefault();
if (impor == null)
{
return(NotFound());
}
}
}
catch
{
return(InternalServerError());
}
return(Ok(impor));
}
public IHttpActionResult Put(int id, Importacion a_modificar)
{
if (id != a_modificar.Id)
{
return(BadRequest());
}
try
{
using (MiContextoContext db = new MiContextoContext())
{
int cantidad = db.importaciones.Count(p => p.Id == id);
if (cantidad == 0)
{
return(NotFound());
}
db.Entry(a_modificar).State = EntityState.Modified;
db.SaveChanges();
return(Ok(a_modificar));
}
}
catch (Exception ex)
{
return(InternalServerError(ex));
}
}
public static IEnumerable <Importacion> LeerImportacionDesdeArchivo(string carpeta, string archivo, string delimitador)
{
RepositorioImportacion repoImp = new RepositorioImportacion();
//lee del archivo delimitado y los almacena en una lista de clientes.
string ruta = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, carpeta, archivo);
List <Importacion> lista = new List <Importacion>();
try
{
using (StreamReader sr = new StreamReader(ruta))
{
string linea = sr.ReadLine();
while (linea != null)
{
Importacion imp = LeerImportacion(linea, delimitador);
if (imp != null && imp.Validar() && !repoImp.FindAll().Contains(imp)) //
{
repoImp.Add(imp);
}
linea = sr.ReadLine();
}
}
return(lista);
}
catch (FileNotFoundException ex)
{
return(null);
}
}
public ActionResult Create(Models.SalidaViewModel sal, Importacion tmpImportacion)
{
if (ModelState.IsValid)
{
if (sal.Matricula.Length > 0 && sal.Direccion.Length > 0)
{
sal.Importacion = tmpImportacion;
sal.Usuario = repoUsu.FindById(Session["ci"]);
sal.FechaSalida = DateTime.Now;
var tareaPost = cliente.PostAsJsonAsync(salidasUri, sal);
var result = tareaPost.Result;
if (result.IsSuccessStatusCode)
{
return(RedirectToAction("Index"));
}
}
TempData["ResultadoOperacion"] = "Ya existe una salida para esa importacion";
return(View());
}
else
{
TempData["ResultadoOperacion"] = "Debe llenar todos los campos";
return(View());
}
}
private static Importacion LeerImportacion(string linea, string delimitador)
{
RepositorioProducto repoPro = new RepositorioProducto();
const int CANT_ATRIBUTOS = 6;
if (!String.IsNullOrEmpty(linea) && !string.IsNullOrEmpty(delimitador))
{
string[] vector = linea.Split(delimitador.ToCharArray());
if (vector.Length == CANT_ATRIBUTOS)
{
Producto pro = new Producto();
pro = repoPro.FindById(int.Parse(vector[3]));
Importacion imp = new Importacion
{
IdImp = int.Parse(vector[0]),
FechaIngreso = DateTime.Parse(vector[1]),
SalidaPrevista = DateTime.Parse(vector[2]),
Producto = pro,
Cantidad = int.Parse(vector[4]),
PrecioFinal = decimal.Parse(vector[5])
};
return(imp);
}
}
return(null);//hay algún error, no se obtiene un cliente. Aquí lo ideal sería grabar en un archivo de log de errores
}
public List <Importacion> TraerTodo()
{
List <Importacion> importaciones = new List <Importacion>();
string strCon = ConfigurationManager.ConnectionStrings["stringConBD"].ConnectionString;
SqlConnection con = new SqlConnection(strCon);
string sql = "SELECT * " +
"FROM Cliente, Producto , Importacion " +
"WHERE Producto.rut = Cliente.rut AND Producto.idProducto = Importacion.idProducto;";
SqlCommand com = new SqlCommand(sql, con);
try
{
con.Open();
SqlDataReader reader = com.ExecuteReader();
while (reader.Read())
{
Cliente unC = new Cliente
{
Id = reader.GetInt32(0),
Rut = reader.GetString(1),
Nombre = reader.GetString(2),
FechaRegistro = reader.GetDateTime(3)
};
Producto unP = new Producto
{
Id = reader.GetInt32(4),
Nombre = reader.GetString(5),
Peso = reader.GetDecimal(6),
Cliente = unC
};
Importacion i = new Importacion
{
Id = reader.GetInt32(8),
Producto = unP,
FechaIngreso = reader.GetDateTime(10),
FechaSalida = reader.GetDateTime(11),
CantidadUnidades = (int)reader.GetDecimal(12),
Precio = reader.GetDecimal(13),
Estado = reader.GetString(14)[0]
};
importaciones.Add(i);
}
con.Close();
}
catch (Exception ex)
{
throw;
}
finally
{
if (con.State == ConnectionState.Open)
{
con.Close();
}
}
return(importaciones);
}
// PUT: api/Importaciones/
public IHttpActionResult Put(int id, [FromBody] ImportacionesVM model)
{
if (!ModelState.IsValid)
{
return(BadRequest("Modelo no valido"));
}
try
{
var existe = repo.FindById(id);
if (existe != null)
{
Importacion imp = new Importacion()
{
Id = id,
CedulaEncargado = model.Cedula,
FechaSalidaFinal = model.FchSalidaPrevista,
MatriculaCamion = model.Matricula
};
repo.Update(imp);
return(Ok(model));
}
return(NotFound());
}
catch (Exception)
{
throw;
}
}
public ActionResult DarSalida(int id)
{
if (Session["rol"].ToString() == "deposito")
{
Importacion impor = null;
Uri uri = new Uri(url + "/Get/" + id);
HttpClient cliente = new HttpClient();
Task <HttpResponseMessage> tarea = cliente.GetAsync(uri);
tarea.Wait();
if (tarea.Result.IsSuccessStatusCode)
{
Task <string> tarea2 = tarea.Result.Content.ReadAsStringAsync();
tarea2.Wait();
string json = tarea2.Result;
impor = JsonConvert.DeserializeObject <Importacion>(json);
}
else
{
ViewBag.Error = tarea.Result.StatusCode;
}
return(View(impor));
}
else
{
return(Redirect("/home/Index"));
}
}
public ActionResult Create(NuevaImportacionViewModel nuevo)
{
if (Session["cedula"] != null)
{
Importacion nuevaImportacion = new Importacion();
bool existe = false;
using (MiContextoContext db = new MiContextoContext())
{
var listaProds = db.Productos
.Join(db.Clientes, prod => prod.Cliente.Id, c => c.Id, (prod, c) => new { prod, c })
.Where(e => e.prod.Codigo == nuevo.CodigoProd).FirstOrDefault();
if (listaProds != null)
{
nuevaImportacion.Producto = listaProds.prod;
existe = true;
}
}
if (existe)
{
nuevaImportacion.Cantidad = nuevo.Cantidad;
nuevaImportacion.FechaIngreso = nuevo.FechaIngreso;
nuevaImportacion.FechaSalidaPrevista = nuevo.FechaSalidaPrevista;
nuevaImportacion.PrecioPorUnidad = nuevo.PrecioPorUnidad;
try
{
Uri uri = new Uri(url + "/Post/");
HttpClient cliente = new HttpClient();
Task <HttpResponseMessage> tarea = cliente.PostAsJsonAsync(uri, nuevaImportacion);
tarea.Wait();
if (!tarea.Result.IsSuccessStatusCode)
{
ViewBag.Error = tarea.Result.StatusCode;
return(View(nuevo));
}
else
{
return(RedirectToAction("Index"));
}
}
catch
{
return(View(nuevo));
}
}
else
{
ViewBag.Mensaje = "No existe producto con tal codigo";
return(View(nuevo));
}
}
else
{
return(Redirect("/home/Index"));
}
}
public static bool AltaImportacion(Importacion i)
{
bool ret = false;
RepoImportacion repo = new RepoImportacion();
if (i.ValidarPrecio())
{
ret = repo.Alta(i);
}
return(ret);
}
public bool AltaImportacion(int cantidad, DateTime fechaIngreso, DateTime fechaSalidaPrevista, int idProd, decimal precioProducto)
{
RepoImportacion repoImp = new RepoImportacion();
Importacion impoNueva = new Importacion()
{
FechaIngreso = fechaIngreso,
FechaSalida = fechaSalidaPrevista,
Producto = FachadaDistribuidora.BuscarProductoPorId(Convert.ToString(idProd)),
Cantidad = cantidad,
PrecioPorUnidad = precioProducto
};
bool exito = repoImp.Alta(impoNueva);
return(exito);
}
public ActionResult DarSalida(Importacion importacion)
{
if (Session["rol"].ToString() == "deposito")
{
bool matriculaValida = importacion.ValidarMatricula();
if (matriculaValida && importacion.Direccion != null)
{
try
{
Uri uri = new Uri(url + "/Put/" + importacion.Id);
HttpClient cliente = new HttpClient();
importacion.FechaSalidaReal = DateTime.Now;
Int32.TryParse(Session["cedula"].ToString(), out int s);
importacion.CiUser = s;
Task <HttpResponseMessage> tarea = cliente.PutAsJsonAsync(uri, importacion);
tarea.Wait();
if (!tarea.Result.IsSuccessStatusCode)
{
Task <string> tarea2 = tarea.Result.Content.ReadAsStringAsync();
tarea2.Wait();
return(View(importacion));
}
else
{
return(RedirectToAction("Index"));
}
}
catch
{
return(View(importacion));
}
}
else
{
ViewBag.Mensaje = "La matricula no es valida.";
return(View(importacion));
}
}
else
{
return(Redirect("/home/Index"));
}
}
public static decimal CalcularGananciaPorImportacion(Importacion i)
{
RepoCliente repoCliente = new RepoCliente();
RepoImportacion r = new RepoImportacion();
decimal ganancia = repoCliente.ObtenerPorcentajeGanancia();
decimal descuento = repoCliente.ObtenerPorcentajeDescuento();
int antiguedad = repoCliente.ObtenerAntiguedadMinima();
decimal total = 0;
if (i != null)
{
total = i.GananciaPrevista(ganancia, descuento, antiguedad);
}
return(total);
}
public static void CargarImportaciones(string rutaWeb)
{
string rutaRelativa = rutaWeb + @"\MVC\Carga\";
StreamReader sr = new StreamReader(rutaRelativa + "Importacion.txt");
string linea = sr.ReadLine();
while (linea != null)
{
string[] textoLinea = linea.Split(new char[] { '#' });
string codigo = textoLinea[5];
//traigo el producto
var queryProd = db.Productos
.Where(prod => prod.Codigo == codigo)
.FirstOrDefault <Producto>();
Int32.TryParse(textoLinea[1], out int cant);
Importacion unaImp = new Importacion()
{
Cantidad = cant,
PrecioPorUnidad = decimal.Parse(textoLinea[2]),
FechaIngreso = DateTime.Parse(textoLinea[3]),
FechaSalidaPrevista = DateTime.Parse(textoLinea[4]),
Producto = queryProd
};
var queryImp = db.importaciones
.Where(i => i.Cantidad == unaImp.Cantidad)
.Where(i => i.PrecioPorUnidad == unaImp.PrecioPorUnidad)
.Where(i => i.FechaIngreso == unaImp.FechaIngreso)
.Where(i => i.FechaSalidaPrevista == unaImp.FechaSalidaPrevista)
.Where(i => i.Producto.Codigo == unaImp.Producto.Codigo)
.FirstOrDefault <Importacion>();
if (queryImp == null)
{
db.importaciones.Add(unaImp);
db.SaveChanges();
}
linea = sr.ReadLine(); //mueve a la siguiente linea
}
sr.Close();
}
public IHttpActionResult PostImporta([FromBody] ImportaPost param)
{
try {
if (!DB.IsCorrectPassword(param.NifRegante, param.PassRegante))
{
return(Json("<h4>Datos de acceso no válidos. Nif o contraseña incorrectos.</h4>"));
}
if (string.IsNullOrWhiteSpace(param.IdTemporada) || !DB.TemporadaExists(param.IdTemporada))
{
return(Json("<h4>La temporada indicada no es válida</h4>"));
}
var lErrores = Importacion.Importar(param);
var ret = Json(lErrores);
return(ret);
} catch (Exception ex) {
return(BadRequest(ex.Message));
}
}
public bool Modificacion(Importacion importacion)
{
bool ret = false;
string strCon = ConfigurationManager.ConnectionStrings["stringConBD"].ConnectionString;
SqlConnection con = new SqlConnection(strCon);
string sql = "UPDATE Importacion " +
"SET idProducto=@idProducto, fechaIngreso=@fechaIngreso, fechaSalida=@fechaSalida, cantUni=@cantUni, precioUni=@precioUni, estado=@estado;" +
"WHERE idImportacion=@id";
SqlCommand com = new SqlCommand(sql, con);
com.Parameters.AddWithValue("@id", importacion.Id);
com.Parameters.AddWithValue("@idProducto", importacion.Producto.Id);
com.Parameters.AddWithValue("@fechaIngreso", importacion.FechaIngreso);
com.Parameters.AddWithValue("@fechaSalida", importacion.FechaSalida);
com.Parameters.AddWithValue("@cantUni", importacion.CantidadUnidades);
com.Parameters.AddWithValue("@precioUni", importacion.Precio);
com.Parameters.AddWithValue("@estado", 'n');
try
{
con.Open();
int afectadas = com.ExecuteNonQuery();
con.Close();
ret = afectadas == 1;
}
catch
{
throw;
}
finally
{
if (con.State == ConnectionState.Open)
{
con.Close();
}
}
return(ret);
}
public IHttpActionResult Post(Importacion nuevo)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
try
{
using (MiContextoContext db = new MiContextoContext())
{
db.importaciones.Add(nuevo);
db.SaveChanges();
}
}
catch
{
return(InternalServerError());
}
return(Created("api/productos/" + nuevo.Id, nuevo));
}
// GET: Importaciones/Details/5
public ActionResult Details(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Importacion importacion = repoImportacion.FindById(id);
ImportacionViewModel vm = new ImportacionViewModel
{
Cantidad = importacion.Cantidad,
FechaIngreso = importacion.FechaIngreso,
IdImp = importacion.IdImp,
SalidaPrevista = importacion.SalidaPrevista,
Producto = importacion.Producto
};
if (importacion == null)
{
return(HttpNotFound());
}
return(View(vm));
}
public bool Add(Salida sal)
{
if (sal != null && sal.Validar())
{
if (FindByIdImp(sal.Importacion.IdImp) == null)
{
Importacion imp = db.Importaciones.Find(sal.Importacion.IdImp);
if (imp != null)
{
sal.Importacion = imp;
Usuario cli = db.Usuarios.Find(sal.Usuario.Ci);
if (cli != null)
{
sal.Usuario = cli;
db.Salidas.Add(sal);
db.SaveChanges();
return(true);
}
}
}
}
return(false);
}
public Importacion BuscarPorId(object id)
{
Importacion importacion = null;
int idBuscado = (int)id;
string strCon = ConfigurationManager.ConnectionStrings["stringConBD"].ConnectionString;
SqlConnection con = new SqlConnection(strCon);
string sql = "SELECT * " +
"FROM Cliente, Producto , Importacion " +
"WHERE Producto.rut = Cliente.rut AND Producto.idProducto = Importacion.idProducto AND Importacion.idImportacion = @id;";
SqlCommand com = new SqlCommand(sql, con);
com.Parameters.AddWithValue("@id", idBuscado);
try
{
con.Open();
SqlDataReader reader = com.ExecuteReader();
if (reader.Read())
{
Cliente unC = new Cliente
{
Id = reader.GetInt32(0),
Rut = reader.GetString(1),
Nombre = reader.GetString(2),
FechaRegistro = reader.GetDateTime(3)
};
Producto unP = new Producto
{
Id = reader.GetInt32(4),
Nombre = reader.GetString(5),
Peso = reader.GetDecimal(6),
Cliente = unC
};
Importacion i = new Importacion
{
Id = reader.GetInt32(8),
Producto = unP,
FechaIngreso = reader.GetDateTime(10),
FechaSalida = reader.GetDateTime(11),
CantidadUnidades = (int)reader.GetDecimal(12),
Precio = reader.GetDecimal(13),
Estado = reader.GetString(14)[0]
};
}
con.Close();
}
catch
{
throw;
}
finally
{
if (con.State == ConnectionState.Open)
{
con.Close();
}
}
return(importacion);
}
public ActionResult SalidaDeImportacion(int?idImp)
{
Importacion tmpImportacion = repoImportacion.FindById(idImp);
return(RedirectToAction("Create", "Salidas", tmpImportacion));
}
public bool PreCarga()
{
try
{
string dirBase = AppDomain.CurrentDomain.BaseDirectory;
string directorio = dirBase + "\\Carga";
string usuario = directorio + "\\Usuario.txt";
string producto = directorio + "\\Productos.txt";
string cliente = directorio + "\\Cliente.txt";
string importacion = directorio + "\\Importaciones.txt";
if (!Directory.Exists(directorio))//Si no existe el directorio lo crea.
{
Directory.CreateDirectory(directorio);
}
if (File.Exists(usuario))//Controla que exista el archivo de los usuarios a precargar
{
StreamReader sr = new StreamReader(usuario);
string linea = sr.ReadLine();
while (linea != null)
{
string separador = "#";
string[] datos = linea.Split(separador.ToCharArray());
Usuario u = new Usuario()
{
CI = datos[0],
Password = datos[1],
Rol = datos[2]
};
this.Add(u);
linea = sr.ReadLine();
}
}
if (File.Exists(cliente))
{
RepositorioCliente repocli = new RepositorioCliente();
StreamReader sr = new StreamReader(cliente);
string linea = sr.ReadLine();
while (linea != null)
{
string separador = "#";
string[] datos = linea.Split(separador.ToCharArray());
Cliente c = new Cliente
{
Rut = datos[0],
Nombre = datos[1]
};
linea = sr.ReadLine();
repocli.Add(c);
}
}
if (File.Exists(producto))
{
RepositorioProducto repositorio = new RepositorioProducto();
StreamReader sr = new StreamReader(producto);
string linea = sr.ReadLine();
while (linea != null)
{
string separador = "#";
string[] datos = linea.Split(separador.ToCharArray());
Producto p = new Producto
{
Codigo = datos[0],
Nombre = datos[1],
Peso = decimal.Parse(datos[3]),
Cliente = db.Clientes.Find(datos[4])
};
linea = sr.ReadLine();
repositorio.Add(p);
}
}
if (File.Exists(importacion))
{
StreamReader sr = new StreamReader(importacion);
string linea = sr.ReadLine();
RepositorioImportacion repositorioImportacion = new RepositorioImportacion();
while (linea != null)
{
string separador = "#";
string[] datos = linea.Split(separador.ToCharArray());
Importacion i = new Importacion
{
Id = 0,
FchIngreso = Convert.ToDateTime(datos[0]),
FchSalidaPrevista = Convert.ToDateTime(datos[1]),
Producto = db.Productos.Find(datos[2]),
Precio = Convert.ToDecimal(datos[4]),
Cantidad = Convert.ToInt32(datos[5]),
Almacenado = Convert.ToBoolean(datos[6]),
};
if (!i.Almacenado)
{
i.FechaSalidaFinal = i.FchSalidaPrevista;
}
repositorioImportacion.Add(i);
linea = sr.ReadLine();
//db.Importaciones.Add(i);
//db.SaveChanges();
}
}
}
catch (Exception)
{
return(false);
}
finally
{
}
return(true);
}
