public Response Crear(TipoTransporte tipoTransporte)
{
try
{
var respuesta = Existe(tipoTransporte);
if (!respuesta.IsSuccess)
{
tipoTransporte.Descripcion = tipoTransporte.Descripcion.TrimStart().TrimEnd().ToUpper();
db.Add(tipoTransporte);
db.SaveChanges();
return(new Response
{
IsSuccess = true,
Message = "Ok",
});
}
else
{
return(new Response
{
IsSuccess = false,
Message = "Existe un tipo de transporte con igual nombre...",
});
}
}
catch (Exception ex)
{
return(new Response
{
IsSuccess = false,
Message = ex.Message,
});
}
}
public Transporte(String fecha_viaje, String origen, String destino, CategoriaTransporte categoriatransporte, TipoTransporte tipotransporte)
{
this.fecha_viaje = fecha_viaje;
this.origen = origen;
this.destino = destino;
this.categoriatransporte = categoriatransporte;
this.tipotransporte = tipotransporte;
}
public ActionResult DeleteConfirmed(int id)
{
TipoTransporte tipoTransporte = unityOfWork.TipoTransporte.Get(id);
unityOfWork.TipoTransporte.Remove(tipoTransporte);
unityOfWork.SaveChanges();
return(RedirectToAction("Index"));
}
public async Task <ActionResult> DeleteConfirmed(int id)
{
TipoTransporte tipoTransporte = await db.TipoTransportes.FindAsync(id);
db.TipoTransportes.Remove(tipoTransporte);
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
private void GetMarcas(TipoTransporte tipTransp)
{
SelectList modelos = new SelectList(db.Modelos.Where(modelo => modelo.activo), "id", "nombre");
if (tipTransp != null)
{
modelos = new SelectList(db.Modelos.Where(modelo => modelo.activo), "id", "nombre", tipTransp.id_modelo);
}
ViewBag.id_modelo = modelos;
}
public ActionResult Edit([Bind(Include = "TipoTransporteID,nombre")] TipoTransporte tipoTransporte)
{
if (ModelState.IsValid)
{
unityOfWork.TipoTransporte.Add(tipoTransporte);
unityOfWork.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(tipoTransporte));
}
public ActionResult Create()
{
TipoTransporte tipTrans = new TipoTransporte();
tipTrans.usr_crea = UtilAut.GetUserId();
tipTrans.fec_crea = DateTime.Now;
tipTrans.id = 0;
GetMarcas(null);
return(View(tipTrans));
}
public void EsMedioDeTransporte_ElTransporteNoCorrespondeAUnTipoRegistrado_DevuelveElTipoNoValido(string medioTransporte)
{
//Arrange
_validadorTransporte = new ValidadorTransporte();
//Act
TipoTransporte transporte = _validadorTransporte.EsMedioDeTransporte(medioTransporte);
//Assert
Assert.AreEqual(TipoTransporte.NoValido, transporte);
}
public ActionResult DeleteConfirmed(int id)
{
//TipoTransporte tipoTransporte = db.TiposTransporte.Find(id);
TipoTransporte tipoTransporte = _UnityOfWork.TipoTransportes.Get(id);
//db.TiposTransporte.Remove(tipoTransporte);
_UnityOfWork.TipoTransportes.Delete(tipoTransporte);
//db.SaveChanges();
_UnityOfWork.SaveChanges();
return(RedirectToAction("Index"));
}
public async Task <ActionResult> Create(TipoTransporte tipoTransporte)
{
if (ModelState.IsValid)
{
db.TipoTransportes.Add(tipoTransporte);
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
GetMarcas(tipoTransporte);
return(View(tipoTransporte));
}
public ActionResult Edit([Bind(Include = "TipoTransporteId,TransporteId")] TipoTransporte tipoTransporte)
{
if (ModelState.IsValid)
{
//db.Entry(tipoTransporte).State = EntityState.Modified;
_UnityOfWork.StateModedified(tipoTransporte);
//db.SaveChanges();
_UnityOfWork.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(tipoTransporte));
}
public ActionResult Create([Bind(Include = "TipoTransporteId,TransporteId")] TipoTransporte tipoTransporte)
{
if (ModelState.IsValid)
{
//db.TiposTransporte.Add(tipoTransporte);
_UnityOfWork.TipoTransportes.Add(tipoTransporte);
//db.SaveChanges();
_UnityOfWork.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(tipoTransporte));
}
public async Task <Response> PostTipoTransporte([FromBody] TipoTransporte TipoTransporte)
{
try
{
if (!ModelState.IsValid)
{
return(new Response
{
IsSuccess = false,
Message = Mensaje.ModeloInvalido
});
}
var respuesta = Existe(TipoTransporte);
if (!respuesta.IsSuccess)
{
db.TipoTransporte.Add(TipoTransporte);
await db.SaveChangesAsync();
return(new Response
{
IsSuccess = true,
Message = Mensaje.Satisfactorio
});
}
return(new Response
{
IsSuccess = false,
Message = Mensaje.ExisteRegistro
});
}
catch (Exception ex)
{
await GuardarLogService.SaveLogEntry(new LogEntryTranfer
{
ApplicationName = Convert.ToString(Aplicacion.SwTH),
ExceptionTrace = ex.Message,
Message = Mensaje.Excepcion,
LogCategoryParametre = Convert.ToString(LogCategoryParameter.Critical),
LogLevelShortName = Convert.ToString(LogLevelParameter.ERR),
UserName = "",
});
return(new Response
{
IsSuccess = false,
Message = Mensaje.Error,
});
}
}
/// <summary>
/// Se encarga de seleccionar un Transporte de acuerdo al ID ingresado
/// </summary>
///<param name="id">EL ID unico del Transporte a consultar</param>
///<returns>Objeto de tipo Transporte</returns>
public static Transporte SeleccionarTransportePorID(int id)
{
using (IDataBase db = FactoryDatabase.CreateDefaultDataBase())
{
SqlCommand comando = new SqlCommand();
comando.CommandType = System.Data.CommandType.StoredProcedure;
comando.CommandText = "PA_SeleccionarTransportePorID";
comando.Parameters.AddWithValue("@id", id);
DataSet ds = db.ExecuteDataSet(comando);
foreach (DataRow dr in ds.Tables[0].Rows)
{
Transporte transporte = null;
TipoTransporte tp = SeleccionarTipoTransportePorID((int)dr["TIPO_TRANSPORTE_ID"]);
//Se crea el objeto transporte de acuerdo a su tipo
FactoryTransporte ft = new FactoryTransporte();
transporte = ft.CrearTransporte(tp);
// Se agregan las propiedades especificas de cada transporte
if (transporte is Bicicleta)
{
(transporte as Bicicleta)._TipoBicicleta = (dr["TIPO_BICICLETA"].ToString().ToLower().Equals("bmx")) ? TipoBicicleta.BMX : TipoBicicleta.MTB;
}
if (transporte is Automovil)
{
(transporte as Automovil).Placa = dr["PLACA"].ToString();
(transporte as Automovil).AlDia = dr["ALDIA"].ToString().ToLower().Equals("true");
}
if (transporte is Motocicleta)
{
(transporte as Motocicleta).Placa = dr["PLACA"].ToString();
(transporte as Motocicleta).AlDia = dr["ALDIA"].ToString().ToLower().Equals("true");
}
//Propiedades generales del objeto
transporte.Id = (int)dr["TRANSPORTE_ID"];
transporte.Marca = dr["MARCA"].ToString();
transporte.Modelo = dr["MODELO"].ToString();
transporte.Color = dr["COLOR"].ToString();
transporte.Activo = dr["Activo"].ToString();
return(transporte);
}
}
return(null);
}
public async Task <ActionResult> Delete(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
TipoTransporte tipoTransporte = await db.TipoTransportes.FindAsync(id);
if (tipoTransporte == null)
{
return(HttpNotFound());
}
return(View(tipoTransporte));
}
// GET: TipoTransportes/Edit/5
public ActionResult Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
TipoTransporte tipoTransporte = unityOfWork.TipoTransporte.Get(id);
if (tipoTransporte == null)
{
return(HttpNotFound());
}
return(View(tipoTransporte));
}
public async Task <ActionResult> Edit(TipoTransporte tipoTransporte)
{
if (ModelState.IsValid)
{
tipoTransporte.usr_modif = UtilAut.GetUserId();
tipoTransporte.fec_modif = DateTime.Now;
db.Entry(tipoTransporte).State = EntityState.Modified;
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
GetMarcas(tipoTransporte);
return(View("Create", tipoTransporte));
}
// GET: TipoTransporte/Details/5
public ActionResult Details(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
//TipoTransporte tipoTransporte = db.TiposTransporte.Find(id);
TipoTransporte tipoTransporte = _UnityOfWork.TipoTransportes.Get(id);
if (tipoTransporte == null)
{
return(HttpNotFound());
}
return(View(tipoTransporte));
}
public async Task <ActionResult> Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
TipoTransporte tipoTransporte = await db.TipoTransportes.FindAsync(id);
if (tipoTransporte == null)
{
return(HttpNotFound());
}
GetMarcas(tipoTransporte);
return(View("Create", tipoTransporte));
}
public JsonResult Post([FromBody] TipoTransporte tipo_transporte)
{
TipoTransporteModel tipoTransporteQuery = new TipoTransporteModel(tipo_transporte);
if (tipoTransporteQuery.Create())
{
ResponseMenssage response = new ResponseMenssage("success", tipoTransporteQuery.Tipo_transporte);
return(new JsonResult(response));
}
else
{
ResponseMenssage response = new ResponseMenssage("error", "error al crear region");
return(new JsonResult(response));
}
}
public CommandContracts.Common.CommandResult Handle(InsertarActualizarTipoTransporteCommand command)
{
if (command == null)
{
throw new ArgumentException("Tiene que ingresar una etapa");
}
TipoTransporte dominio = null;
if (command.idtipotransporte.HasValue)
{
dominio = _TipoTransporteRepository.Get(x => x.idtipotransporte == command.idtipotransporte).LastOrDefault();
}
else
{
dominio = new TipoTransporte();
}
if (command.activo)
{
dominio.activo = command.activo;
}
else
{
dominio.tipotransporte = command.tipotransporte;
}
try
{
if (!command.idtipotransporte.HasValue)
{
_TipoTransporteRepository.Add(dominio);
}
_TipoTransporteRepository.Commit();
return(new InsertarTipoTransporteOutput()
{
idtipotransporte = dominio.idtipotransporte
});
}
catch (Exception ex)
{
_TipoTransporteRepository.Delete(dominio);
_TipoTransporteRepository.Commit();
throw;
}
}
public JsonResult Put(int id, [FromBody] TipoTransporte tipo_transporte)
{
TipoTransporteModel tipoTransporteQuery = new TipoTransporteModel(tipo_transporte);
tipoTransporteQuery.Tipo_transporte.Id = id;
if (tipoTransporteQuery.Update())
{
ResponseMenssage response = new ResponseMenssage("success", tipoTransporteQuery.Tipo_transporte);
return(new JsonResult(response));
}
else
{
ResponseMenssage response = new ResponseMenssage("error", "error al modificar tipo_transporte");
return(new JsonResult(response));
}
}
/// <summary>
/// Crea la instancia al Transporte dependiendo del tipo de transporte
/// </summary>
/// <param name="tp">Enum tipo transporte</param>
/// <returns>Objeto tipo Transporte</returns>
public Transporte CrearTransporte(TipoTransporte tp)
{
if (tp == TipoTransporte.Bicicleta)
{
_Transporte = new Bicicleta();
}
if (tp == TipoTransporte.Motocicleta)
{
_Transporte = new Motocicleta();
}
if (tp == TipoTransporte.Automovil)
{
_Transporte = new Automovil();
}
return(_Transporte);
}
public async Task <IActionResult> Edit(string id, TipoTransporte TipoTransporte)
{
Response response = new Response();
try
{
if (!string.IsNullOrEmpty(id))
{
response = await apiServicio.EditarAsync(id, TipoTransporte, new Uri(WebApp.BaseAddress),
"/api/TiposDeTransporte");
if (response.IsSuccess)
{
await GuardarLogService.SaveLogEntry(new LogEntryTranfer
{
ApplicationName = Convert.ToString(Aplicacion.WebAppTh),
EntityID = string.Format("{0} : {1}", "Sistema", id),
LogCategoryParametre = Convert.ToString(LogCategoryParameter.Edit),
LogLevelShortName = Convert.ToString(LogLevelParameter.ADV),
Message = "Se ha actualizado un registro sistema",
UserName = "******"
});
return(RedirectToAction("Index"));
}
ViewData["Error"] = response.Message;
return(View(TipoTransporte));
}
return(BadRequest());
}
catch (Exception ex)
{
await GuardarLogService.SaveLogEntry(new LogEntryTranfer
{
ApplicationName = Convert.ToString(Aplicacion.WebAppTh),
Message = "Editando un tipo de transporte",
ExceptionTrace = ex,
LogCategoryParametre = Convert.ToString(LogCategoryParameter.Edit),
LogLevelShortName = Convert.ToString(LogLevelParameter.ERR),
UserName = "******"
});
return(BadRequest());
}
}
public async Task <IActionResult> Create(TipoTransporte TipoTransporte)
{
Response response = new Response();
try
{
response = await apiServicio.InsertarAsync(TipoTransporte,
new Uri(WebApp.BaseAddress),
"/api/TiposDeTransporte/InsertarTipoTransporte");
if (response.IsSuccess)
{
var responseLog = await GuardarLogService.SaveLogEntry(new LogEntryTranfer
{
ApplicationName = Convert.ToString(Aplicacion.WebAppTh),
ExceptionTrace = null,
Message = "Se ha creado un tipo de transporte",
UserName = "******",
LogCategoryParametre = Convert.ToString(LogCategoryParameter.Create),
LogLevelShortName = Convert.ToString(LogLevelParameter.ADV),
EntityID = string.Format("{0} {1}", "TipoTransporte:", TipoTransporte.IdTipoTransporte),
});
return(RedirectToAction("Index"));
}
ViewData["Error"] = response.Message;
return(View(TipoTransporte));
}
catch (Exception ex)
{
await GuardarLogService.SaveLogEntry(new LogEntryTranfer
{
ApplicationName = Convert.ToString(Aplicacion.WebAppTh),
Message = "Creando un tipo de transporte",
ExceptionTrace = ex,
LogCategoryParametre = Convert.ToString(LogCategoryParameter.Create),
LogLevelShortName = Convert.ToString(LogLevelParameter.ERR),
UserName = "******"
});
return(BadRequest());
}
}
public JsonResult Get(int id)
{
TipoTransporte tipo_transporte = new TipoTransporte
{
Id = id
};
TipoTransporteModel tipoTransporteQuery = new TipoTransporteModel(tipo_transporte);
if (tipoTransporteQuery.ReadById())
{
ResponseMenssage response = new ResponseMenssage("success", tipoTransporteQuery.Tipo_transporte);
return(new JsonResult(response));
}
else
{
ResponseMenssage response = new ResponseMenssage("error", "tipo_transporte no encontrada");
return(new JsonResult(response));
}
}
private Response Existe(TipoTransporte TipoTransporte)
{
var bdd = TipoTransporte.Descripcion;
var TipoTransporterespuesta = db.TipoTransporte.Where(p => p.Descripcion == bdd).FirstOrDefault();
if (TipoTransporterespuesta != null)
{
return(new Response
{
IsSuccess = true,
Message = Mensaje.ExisteRegistro,
Resultado = null,
});
}
return(new Response
{
IsSuccess = false,
Resultado = TipoTransporterespuesta,
});
}
public Response Existe(TipoTransporte tipoTransporte)
{
var respuestaTipoTransporte = db.TipoTransporte.Where(p => p.Descripcion.ToUpper() == tipoTransporte.Descripcion.TrimStart().TrimEnd().ToUpper()).FirstOrDefault();
if (respuestaTipoTransporte != null)
{
return(new Response
{
IsSuccess = true,
Message = "Existe un tipo de transporte de igual nombre",
Resultado = null,
});
}
return(new Response
{
IsSuccess = false,
Message = "No existe el tipo de transporte...",
Resultado = db.TipoTransporte.Where(p => p.IdTipoTransporte == tipoTransporte.IdTipoTransporte).FirstOrDefault(),
});
}
/// <summary>
/// Buscar las ofertas de las subastas segun la id de esta
/// </summary>
/// <param name="idSubasta"></param>
/// <returns></returns>
public static List <OfertaSubasta> ListarOfertaPorIdSubasta(int idSubasta)
{
//Creacion de una factory de Transportista
TipoUsuarioFactory factory = new TransportistaFactory();
using (var db = new DBEntities())
{
try
{
List <OfertaSubasta> listado = new List <OfertaSubasta>();
var queryOfertas = db.OFERTASUBASTA.Where(ofer => ofer.IDSUBASTA == idSubasta).ToList();
foreach (var oferta in queryOfertas)
{
OfertaSubasta ofertaSubasta = new OfertaSubasta();
ofertaSubasta.IdOferta = (int)oferta.IDOFERTA;
ofertaSubasta.FechaOferta = oferta.FECHAOFERTA;
ofertaSubasta.Seleccionado = oferta.SELECCIONADO;
ofertaSubasta.PrecioOferta = (float)oferta.PRECIOOFERTA;
ofertaSubasta.Transportista = (TiposUsuario.Transportista)factory.createTipoUsuario();
ofertaSubasta.Transportista.ObtenerDatosPorId((int)oferta.IDTRANSPORTISTA);
ofertaSubasta.IdSubasta = (int)oferta.IDSUBASTA;
TipoTransporte tipo = new TipoTransporte();
tipo.IdTipo = (int)oferta.IDTIPOTRANSPORTE;
tipo.GetById();
ofertaSubasta.TipoTransporte = tipo;
listado.Add(ofertaSubasta);
}
return(listado);
}catch (Exception ex)
{
ex.InnerException.ToString();
return(null);
}
}
}
public async Task <Response> PutTipoTransporte([FromRoute] int id, [FromBody] TipoTransporte TipoTransporte)
{
try
{
if (!ModelState.IsValid)
{
return(new Response
{
IsSuccess = false,
Message = Mensaje.ModeloInvalido
});
}
var existe = Existe(TipoTransporte);
if (existe.IsSuccess)
{
return(new Response
{
IsSuccess = false,
Message = Mensaje.ExisteRegistro,
});
}
var TipoTransporteActualizar = await db.TipoTransporte.Where(x => x.IdTipoTransporte == id).FirstOrDefaultAsync();
if (TipoTransporteActualizar != null)
{
try
{
TipoTransporteActualizar.Descripcion = TipoTransporte.Descripcion;
await db.SaveChangesAsync();
return(new Response
{
IsSuccess = true,
Message = Mensaje.Satisfactorio,
});
}
catch (Exception ex)
{
await GuardarLogService.SaveLogEntry(new LogEntryTranfer
{
ApplicationName = Convert.ToString(Aplicacion.SwTH),
ExceptionTrace = ex.Message,
Message = Mensaje.Excepcion,
LogCategoryParametre = Convert.ToString(LogCategoryParameter.Critical),
LogLevelShortName = Convert.ToString(LogLevelParameter.ERR),
UserName = "",
});
return(new Response
{
IsSuccess = false,
Message = Mensaje.Error,
});
}
}
return(new Response
{
IsSuccess = false,
Message = Mensaje.ExisteRegistro
});
}
catch (Exception)
{
return(new Response
{
IsSuccess = false,
Message = Mensaje.Excepcion
});
}
}
