public async Task <IHttpActionResult> createCierre(CierreDTO cierre)
{
Respuesta response = new Respuesta();
cierre.Fecha = DateTime.Now.Date;
var user = await this.AppUserManager.FindByNameAsync(cierre.UserName);
if (user == null)
{
response.Mensagge = "El Usuario No Existe";
response.Errors.Add(new ResponseErrorDTO("", "El Usuario No se Encuentra Registrado, Verifique el nombre de usuario"));
return(Ok(response));
}
RespuestaDTO <AdministradorDTO> administradorQuery = await new AdministradorBLL().FindByIdAdmin(user.Id);
if (administradorQuery.Errors.Count > 0)
{
return(Ok(administradorQuery));
}
cierre.AdministradorId = user.Id;
cierre.AlmacenId = administradorQuery.Data.AlmacenId;
return(GetActionResult(new Callback(CreateCierre), cierre));
}
public async Task <IHttpActionResult> CreateInvercionista(InversionistaDTO invercionista)
{
Respuesta response = new Respuesta();
UsuarioAlmacenDTO adminDTO = await this.getVerificarUserAlmacen(invercionista.UserName, invercionista.AlmacenId);
if (adminDTO.response != null)
{
return(Ok(adminDTO.response));
}
if (adminDTO.AlmacenId != 0 && adminDTO.UserId != null)
{
invercionista.UserId = adminDTO.UserId;
invercionista.AlmacenId = adminDTO.AlmacenId;
RespuestaDTO <InversionistaDTO> r = CreateInvercionistaAlmacen(invercionista);
if (r.Errors.Count == 0)
{
this.AppUserManager.AddToRoles(invercionista.UserId, new string[] { "inversionista" });
r.Mensagge += ", Se Agrego Role inversionista";
}
return(Ok(r));
}
response.Errors.Add(new ResponseErrorDTO {
Code = "404", Mensagge = "Verifique La Informacion Suministrada"
});
response.Mensagge = "No se encontro Informacion";
return(Ok(response));
}
/// <summary>
/// Inicia el temporizador y devuelve un PreguntaDTO correspondiente a la siguiente de la sesión
/// </summary>
/// <param name="pOnTimeFinishedHandler">La acción a realizar cuando se agota el tiempo límite</param>
/// <param name="pOnTickTimer">La acción a realizar por cada tick</param>
/// <param name="pIdSesionActual">El ID de la sesión actual</param>
/// <returns></returns>
public PreguntaDTO ObtenerPreguntaYRespuestas(Action pOnTimeFinishedHandler, Action <int> pOnTickTimer, int pIdSesionActual)
{
Random random = new Random();
PreguntaDTO preguntaYRespuestas = new PreguntaDTO();
Sesion sesionActual = ServiciosSesion.ObtenerSesion(pIdSesionActual);
Pregunta pregunta = ServiciosPregunta.ObtenerPregunta(sesionActual.ObtenerIdSiguientePregunta());
int tiempoRestante = Convert.ToInt32(sesionActual.TiempoLimite() - sesionActual.SegundosTranscurridos);
ayudanteTimer = new AyudanteTimer(tiempoRestante, pOnTimeFinishedHandler, pOnTickTimer);
preguntaYRespuestas.IdPregunta = pregunta.PreguntaId;
preguntaYRespuestas.Pregunta = pregunta.Nombre;
RespuestaDTO respuestaActualDTO;
List <RespuestaDTO> listaDeRespuestas = new List <RespuestaDTO>();
foreach (Respuesta respuesta in pregunta.Respuestas)
{
respuestaActualDTO = new RespuestaDTO();
respuestaActualDTO.IdRespuesta = respuesta.RespuestaId;
respuestaActualDTO.Respuesta = respuesta.DefRespuesta;
listaDeRespuestas.Add(respuestaActualDTO);
}
preguntaYRespuestas.Respuestas = listaDeRespuestas.OrderBy(x => random.Next()).ToList();
return(preguntaYRespuestas);
}
public RespuestaDTO ListarProductosPorTipo(int tipo)
{
RespuestaDTO respuesta = new RespuestaDTO();
try
{
var productosPorTipo = contexto.Productos.Where(P => P.TipProducto == tipo).ToList();
if (productosPorTipo.Count > 0)
{
respuesta.ContenidoRespuesta = 1;
respuesta.ContenidoRespuesta = productosPorTipo;
return(respuesta);
}
else
{
throw new Exception("No se encontraron productos para el tipo indicado en la base de datos");
}
}
catch (Exception error)
{
respuesta.CodigoRespuesta = -1;
respuesta.ContenidoRespuesta = new ErrorDTO {
MensajeError = error.Message
};
return(respuesta);
}
}
public async Task <RespuestaDTO <UserDTO> > createUser(CreateUserDTO createUserModel)
{
ApplicationUser user = new ApplicationUser()
{
UserName = createUserModel.UserName,
Email = createUserModel.Email,
FirstName = createUserModel.FirstName,
LastName = createUserModel.LastName,
Level = 3,
JoinDate = DateTime.Now.Date,
};
RespuestaDTO <UserDTO> response = new RespuestaDTO <UserDTO>();
response.Error = ApplicationUserManager.Result(await UserManager.CreateAsync(user, createUserModel.Password));
await UserManager.AddToRolesAsync(UserManager.FindByNameAsync(user.UserName).Result.Id, new string[] { "Institucion" });
// ApplicationUserManager.AddToRoles(adminUser.Id, new string[] { "SuperAdmin", "Admin" });
if (response.Error.Count > 0)
{
response.Mensaje = "El Usuario No Ha Sido Creado";
}
else
{
response.Mensaje = "Se Ha Creado Un Nuevo Usuario";
response.Data = setUserDTO(user);
}
return(response);
}
private string Validar(RespuestaDTO Resp = null)
{
string Mensaje = string.Empty;
ModelState.Clear();
if (Resp != null)
{
if (Resp.ModelStatesStandar != null)
{
foreach (var error in Resp.ModelStatesStandar.ToList())
{
ModelState.AddModelError(error.Key, error.Value);
}
}
if (Resp.MensajesError != null)
{
if (Resp.MensajesError.Count > 1)
{
Mensaje = Resp.MensajesError[0] + " " + Resp.MensajesError[1];
}
else
{
Mensaje = Resp.MensajesError[0];
}
}
}
return(Mensaje);
}
// GET: Empresas
public ActionResult Index()
{
if (Session["StringToken"] == null)
{
return(RedirectToAction("Index", "Home", AutenticacionServicio.InitIndex(new Models.Seguridad.LoginModel())));
}
_tok = Session["StringToken"].ToString();
RespuestaDTO Resp = new RespuestaDTO();
ViewBag.EsAdmin = TokenServicio.ObtenerEsAdministracionCentral(_tok);
if (ViewBag.EsAdmin)
{
ViewBag.Empresas = CatalogoServicio.Empresas(_tok);
}
else
{
ViewBag.Empresas = CatalogoServicio.Empresas(_tok).SingleOrDefault().NombreComercial;
}
ViewBag.listaEmpresas = CatalogoServicio.Empresas(_tok);
if (TempData["RespuestaDTO"] != null)
{
ViewBag.MessageExito = TempData["RespuestaDTO"];
}
if (TempData["RespuestaDTOError"] != null)
{
ViewBag.MessageError = Validar((RespuestaDTO)TempData["RespuestaDTOError"]);
//ViewBag.MessageError = TempData["RespuestaDTOError"];
}
//ViewBag.MessageError = TempData["RespuestaDTOError"];
return(View());
}
public async Task <IHttpActionResult> CreateUser(CreateUserBindingModel createUserModel)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
RespuestaDTO <UserDTO> user = await new UserBLL(Request).createUser(new CreateUserDTO
{
UserName = createUserModel.Username,
Email = createUserModel.Email,
FirstName = createUserModel.FirstName,
LastName = createUserModel.LastName,
Level = 3,
JoinDate = DateTime.Now.Date,
Password = createUserModel.Password
});
if (user.Error.Count > 0)
{
return(GetErrorResult(user));
}
Uri locationHeader = new Uri(Url.Link("GetUserById", new { id = user.Data.Id }));
return(Created(locationHeader, user));
}
public HttpResponseMessage CrearCP([FromBody] RespuestaDTO dto)
{
// CAD, CEN, returnValue, returnOID
RespuestaRESTCAD respuestaRESTCAD = null;
RespuestaCEN respuestaCEN = null;
RespuestaDTOA returnValue = null;
RespuestaCP respuestaCP = null;
int returnOID = -1;
// HTTP response
HttpResponseMessage response = null;
string uri = null;
try
{
SessionInitializeTransaction();
respuestaRESTCAD = new RespuestaRESTCAD(session);
respuestaCEN = new RespuestaCEN(respuestaRESTCAD);
respuestaCP = new RespuestaCP(session);
// Create
returnOID = respuestaCEN.Crear(dto.Cuerpo, dto.Duda_oid, dto.Usuario_oid);
respuestaCP.CrearAccionRespuesta(returnOID);
SessionCommit();
// Convert return
returnValue = RespuestaAssembler.Convert(respuestaRESTCAD.ReadOIDDefault(returnOID), session);
}
catch (Exception e)
{
SessionRollBack();
if (e.GetType() == typeof(HttpResponseException))
{
throw e;
}
else if (e.GetType() == typeof(ReciclaUAGenNHibernate.Exceptions.ModelException) && e.Message.Equals("El token es incorrecto"))
{
throw new HttpResponseException(HttpStatusCode.Forbidden);
}
else if (e.GetType() == typeof(ReciclaUAGenNHibernate.Exceptions.ModelException) || e.GetType() == typeof(ReciclaUAGenNHibernate.Exceptions.DataLayerException))
{
throw new HttpResponseException(HttpStatusCode.BadRequest);
}
else
{
throw new HttpResponseException(HttpStatusCode.InternalServerError);
}
}
finally
{
SessionClose();
}
// Return 201 - Created
response = this.Request.CreateResponse(HttpStatusCode.Created, returnValue);
return(response);
}
public RespuestaDTO <AdministradorDTO> InsertarAdministrador(AdministradorDTO administrador)
{
using (db = new Contexto())
{
RespuestaDTO <AdministradorDTO> response = new RespuestaDTO <AdministradorDTO>();
try
{
// preparar el admin para guardar
Administrador admin = new Administrador();
admin.AdministradorId = administrador.UserId;
admin.AlmacenId = administrador.AlmacenId;
db.Administradores.Add(admin);
// preparar la respuesta
response.Rows = db.SaveChanges();
response.Mensagge = "Se Ha Agregado El Administrador Correctamente.";
response.Data = administrador;
}
catch (System.Data.Entity.Validation.DbEntityValidationException ex)
{
response.Mensagge = "Se Ha Presentado Un Error Al Guardar El Almacen";
response.Errors.Add(new ResponseErrorDTO(ex.GetHashCode().ToString(), ex.Message));
return(response);
}
catch (Exception ex)
{
response.Mensagge = "Se Ha Presentado Un Error";
response.Errors.Add(new ResponseErrorDTO(ex.GetHashCode().ToString(), ex.Message));
response.Errors.Add(new ResponseErrorDTO("", "El Admin Ya se Encuentre Registrado a este almacen."));
}
return(response);
}
}
private void btn_Click(object sender, EventArgs e)
{
Button btn = sender as Button;
if (btn.Text != "")
{
RespuestaDTO respuesta = new RespuestaDTO(btn.Text);
respuesta = preguntaDto.Respuestas.Single(res => res.PosibleRespuesta == respuesta.PosibleRespuesta);
int posi = preguntaDto.Respuestas.IndexOf(respuesta);
if (preguntaDto.Respuestas[posi].Valida)
{
btn.BackColor = Color.Green;
contValido += 1;
btn.Enabled = false;
}
else
{
btn.BackColor = Color.Red;
btn.Enabled = false;
contNoValido += 1;
lblRespuestaValida.Text = respuesta.ExplicacionErronea.ToString();
}
if (contValido == 8)
{
AciertosFallos("acertado", 8);
}
else if (contNoValido == 4)
{
AciertosFallos("fallado", 4);
}
}
}
public IHttpActionResult Eliminar_Mecanico(string id)
{
var IOperacion = GeneradorOperacionBL.InstanciarClase(Enumeradores.clases.MecanicoBL.ToStringAttribute());
RespuestaDTO response = IOperacion.EjecutarOperacion(Enumeradores.clases.MecanicoBL.ToStringAttribute(), System.Reflection.MethodBase.GetCurrentMethod().Name, new List <string> {
id
});
return(Ok(response));
}
public IHttpActionResult Actualizar_Mecanico(MecanicoDTO Mecanico)
{
var IOperacion = GeneradorOperacionBL.InstanciarClase(Enumeradores.clases.MecanicoBL.ToStringAttribute());
RespuestaDTO response = IOperacion.EjecutarOperacion(Enumeradores.clases.MecanicoBL.ToStringAttribute(), System.Reflection.MethodBase.GetCurrentMethod().Name, new List <string> {
JsonConvert.SerializeObject(Mecanico)
});
return(Ok(response));
}
public RespuestaDTO <InversionistaDTO> InsertarInvercionista(InversionistaDTO invercionitaModel)
{
using (db = new Contexto())
{
RespuestaDTO <InversionistaDTO> response = new RespuestaDTO <InversionistaDTO>();
try
{
if (invercionitaModel.UserId == null)
{
response.Mensagge = "Ingrese El Id Del Usuario";
response.Errors.Add(new ResponseErrorDTO {
Code = "404", Mensagge = "El Id SE Envio Vacio."
});
return(response);
}
// preparar el invercioinista para guardar
Invercionista invercionista = new Invercionista();
invercionista.InvercionistaId = invercionitaModel.UserId;
var inv = db.Invercionistas.Find(invercionitaModel.UserId);
if (inv == null)
{
db.Invercionistas.Add(invercionista);
response.Rows = db.SaveChanges();
if (response.Rows == 0)
{
response.Mensagge = "No Se Pudo Guardar El Invercionista. ";
response.Errors.Add(new ResponseErrorDTO("", "Error Al almacenar el invercionista."));
return(response);
}
}
AlmacenInversionista inver = new AlmacenInversionista();
inver.AlmacenId = invercionitaModel.AlmacenId;
inver.InversionistaId = invercionitaModel.UserId;
db.AlmacenInversionistas.Add(inver);
response.Rows = db.SaveChanges();
response.Mensagge = "Se Ha Guaradado El Invercionista satisfactoriamente";
response.Data = invercionitaModel;
}
catch (System.Data.Entity.Validation.DbEntityValidationException ex)
{
response.Mensagge = "Se Ha Presentado Un Error Al Guardar El Invercionista";
response.Errors.Add(new ResponseErrorDTO(ex.GetHashCode().ToString(), ex.Message));
return(response);
}
catch (Exception ex)
{
response.Mensagge = "Se Ha Presentado Un Error";
response.Errors.Add(new ResponseErrorDTO(ex.GetHashCode().ToString(), ex.Message));
response.Errors.Add(new ResponseErrorDTO("", "El Invercionista Ya Ha Sido Agregado Al Almacen."));
}
return(response);
}
}
public RespuestaDTO <TotalBalanceGeneralAlmacenesDTO> getBalanceGeneral(SolicitudReporteDTO solicitud)
{
RespuestaDTO <TotalBalanceGeneralAlmacenesDTO> response = new RespuestaDTO <TotalBalanceGeneralAlmacenesDTO>();
try
{
TotalBalanceGeneralAlmacenesDTO balanceGeneralAlmacenes = new TotalBalanceGeneralAlmacenesDTO();
List <TotalBalanceGeneralAlmacen> balanceGeneralAlmacen = new List <TotalBalanceGeneralAlmacen>();
foreach (AlmacenDTO almacen in solicitud.ListadoAlmacenes)
{
TotalBalanceGeneralAlmacen balanceAlmacen = new TotalBalanceGeneralAlmacen();
List <BalanceGeneralDTO> cierres = new List <BalanceGeneralDTO>();
balanceAlmacen.Almacen = almacen;
var query = db.Cierres.Where(cierre => cierre.Fecha <= solicitud.FechaFin && cierre.Fecha >= solicitud.FechaIni && cierre.AlmacenId == almacen.AlmacenId).OrderBy(c => c.Fecha).ToList <Cierre>();
foreach (Cierre c in query)
{
cierres.Add(new BalanceGeneralDTO
{
Fecha = c.Fecha.ToShortDateString(),
TotalCostos = c.Invercion + c.Facturas,
TotalGastos = c.Costos,
TotalVentas = c.Bancos + c.Efectivo,
Utilidad = (c.Bancos + c.Efectivo) - (c.Invercion + c.Facturas) - c.Costos
});
balanceAlmacen.TotalCostos += c.Facturas + c.Invercion;
balanceAlmacen.TotalGastos += c.Costos;
balanceAlmacen.TotalVentas += c.Bancos + c.Efectivo;
balanceAlmacen.TotalUtilidad = balanceAlmacen.TotalVentas - balanceAlmacen.TotalGastos - balanceAlmacen.TotalCostos;
}
balanceGeneralAlmacenes.TotalGastos += balanceAlmacen.TotalGastos;
balanceGeneralAlmacenes.TotalCostos += balanceAlmacen.TotalCostos;
balanceGeneralAlmacenes.TotalVentas += balanceAlmacen.TotalVentas;
balanceGeneralAlmacenes.TotalUtilidad += balanceAlmacen.TotalUtilidad;
balanceAlmacen.balances = cierres;
balanceGeneralAlmacen.Add(balanceAlmacen);
}
balanceGeneralAlmacenes.BalancePorAlmacen = balanceGeneralAlmacen;
response.Data = balanceGeneralAlmacenes;
response.Mensagge = "Consulta Realizada Con Exito";
return(response);
}
catch (Exception e)
{
response.Mensagge = "Se Ha Presentado Un Error";
response.Errors.Add(new ResponseErrorDTO("500", e.Message));
return(response);
}
}
public async Task <IHttpActionResult> DeleteRole(string Id)
{
RespuestaDTO <RoleDTO> response = await new RoleBLL(Request).DeleteRole(Id);
if (response.Error.Count > 0)
{
return(GetErrorResult(response));
}
return(Ok(response));
}
public async Task <IHttpActionResult> ManageUsersInRole(UsersInRoleModelDTO model)
{
RespuestaDTO <UsersInRoleModelDTO> response = await new RoleBLL(Request).ManageUsersInRole(model);
if (response.Error.Count > 0)
{
GetErrorResult(response);
}
return(Ok(response));
}
public async Task <IHttpActionResult> AssignRolesToUser([FromUri] string id, [FromBody] string[] rolesToAssign)
{
RespuestaDTO <string[]> response = await new UserBLL(Request).AssignRolesToUser(id, rolesToAssign);
if (response.Error.Count > 0)
{
return(GetErrorResult(response));
}
return(Ok(response));
}
public RespuestaDTO <List <DocenteDTO> > getDocentes(string idInstitucion)
{
RespuestaDTO <List <DocenteDTO> > response = new RespuestaDTO <List <DocenteDTO> >();
response.Mensaje = "Listado de docentes";
using (db = new Contexto())
{
var docentes = db.Docentes.Where(d => d.Institucion == idInstitucion).ToList();
response.Data = DocenteToDocenteDTO(docentes);
return(response);
}
}
public RespuestaDTO <TotalCostosAlmacenesDTO> getCostos(SolicitudReporteDTO solicitud)
{
RespuestaDTO <TotalCostosAlmacenesDTO> response = new RespuestaDTO <TotalCostosAlmacenesDTO>();
try
{
TotalCostosAlmacenesDTO totalCostos = new TotalCostosAlmacenesDTO();
List <TotalCostosAlmacenDTO> costos = new List <TotalCostosAlmacenDTO>();
foreach (AlmacenDTO almacen in solicitud.ListadoAlmacenes)
{
TotalCostosAlmacenDTO costosAlmacen = new TotalCostosAlmacenDTO();
List <DatosCostosDTO> cierres = new List <DatosCostosDTO>();
costosAlmacen.Almacen = almacen;
var query = db.Cierres.Where(cierre => cierre.Fecha <= solicitud.FechaFin && cierre.Fecha >= solicitud.FechaIni && cierre.AlmacenId == almacen.AlmacenId).OrderBy(c => c.Fecha).ToList <Cierre>();
foreach (Cierre c in query)
{
cierres.Add(new DatosCostosDTO
{
Fecha = c.Fecha.ToShortDateString(),
Facturas = c.Facturas,
Invercion = c.Invercion,
Total = c.Facturas + c.Invercion
});
costosAlmacen.TotalInversion += c.Invercion;
costosAlmacen.TotalFacturas += c.Efectivo;
costosAlmacen.TotalCostos += c.Facturas + c.Invercion;
}
totalCostos.TotalInverciones += costosAlmacen.TotalInversion;
totalCostos.TotalFacturas += costosAlmacen.TotalFacturas;
totalCostos.TotalCostos += costosAlmacen.TotalCostos;
costosAlmacen.costos = cierres;
costos.Add(costosAlmacen);
}
totalCostos.costosPorAlmacen = costos;
response.Data = totalCostos;
response.Mensagge = "Consulta Realizada Con Exito";
return(response);
}
catch (Exception e)
{
response.Mensagge = "Se Ha Presentado Un Error";
response.Errors.Add(new ResponseErrorDTO("500", e.Message));
return(response);
}
}
public Object Post(RespuestaDTO respuesta)
{
try
{
BusinessLogic.Controllers.RespuestaController respuestaController = new BusinessLogic.Controllers.RespuestaController();
var resp = respuestaController.Create(respuesta);
return(new ResponseDTO(resp, "Se ha creado la respuesta correctamente.", true));
}
catch (Exception e) {
return(Content(HttpStatusCode.InternalServerError, new ResponseDTO(null, e.Message, false)));
}
}
public RespuestaDTO <List <EquiposDTO> > getEquipos()
{
RespuestaDTO <List <EquiposDTO> > response = new RespuestaDTO <List <EquiposDTO> >();
response.Mensaje = "Listado de equipos";
using (db = new Contexto())
{
var Equipos = db.Equipos.ToList();
response.Data = EquiposToEquiposDTO(Equipos);
return(response);
}
}
/*
* public List<Equipos> Consulta(DateTime fechaInicial, DateTime fechaFinal, String Tipo)
* {
* using (Contexto db = new Contexto())
* {
* var sql = @"SELECT *from Equipos where not EquiposId in (select ea.Equipos_EquiposId from Alquiler a, EquiposAlquiler ea where a.AlquilerId=ea.Alquiler_AlquilerId and @fechaInicial BETWEEN a.fechaInicial and a.fechaFinal and @fechaFinal BETWEEN a.fechaInicial AND a.fechaFinal union select ea.Equipos_EquiposId from Alquiler a, EquiposAlquiler ea where a.AlquilerId=ea.Alquiler_AlquilerId and a.fechaInicial BETWEEN @fechaInicial and @fechaFinal AND a.fechaFinal BETWEEN @fechaInicial and @fechaFinal) and Tipo=@Tipo";
*
* object[] parameters = new object[] {
* new SqlParameter("@fechaInicial", fechaInicial),
* new SqlParameter("@Tipo", Tipo),
* new SqlParameter("@fechaFinal", fechaFinal) };
* List<Equipos> ListaEquipos = db.Database.SqlQuery<Equipos>(sql, parameters).ToList();
* return ListaEquipos;
* /*
* ObjectQuery<Equipos> contactQuery =
* new ObjectQuery<Equipos>(sql, db.Database)
*
* // The following query returns a collection of Contact objects.
* ObjectQuery<Equipos> query = new ObjectQuery<Equipos>(sql, db, MergeOption.NoTracking);
* query.Parameters.Add(new ObjectParameter("ln", "Zhou"));
*
* // Add parameters to the collection.
* contactQuery.Parameters.Add(new ObjectParameter("@fechaInicial", fechaInicial));
* contactQuery.Parameters.Add(new ObjectParameter("@Tipo",Tipo));
* contactQuery.Parameters.Add(new ObjectParameter("@fechaFinal", fechaFinal));
*
* }
*
*
*
*
*
*
* }
*
*/
public RespuestaDTO <List <AlquilerInstitucionDTO> > getAlquileresDocente(int docenteId)
{
RespuestaDTO <List <AlquilerInstitucionDTO> > response = new RespuestaDTO <List <AlquilerInstitucionDTO> >();
using (db = new Contexto())
{
var Alquileres = db.AlquilerInstitucion.Where(t => (t.Docente.DocenteId == docenteId)).ToList();
response.Mensaje = "Listado Alquileres";
response.Data = AlquilerInstitucionToAlquilerInstitucionDTO(Alquileres);
return(response);
}
}
public ActionResult DatosCliente(FacturacionModel _mod)
{
if (TempData["RespuestaDTO"] != null)
{
var Respuesta = (RespuestaDTO)TempData["RespuestaDTO"];
if (Respuesta.Exito)
{
ViewBag.Msj = Respuesta.Mensaje;
}
else
{
ViewBag.MensajeError = Validar(Respuesta);
}
}
//verificar si las facturas agregadas pertenecen al mismo cliente
var idCliente = _mod.Tickets[0].IdCliente;
foreach (var tick in _mod.Tickets.Where(x => x.seleccionar).ToList())
{
if (tick.IdCliente != idCliente)
{
TempData["RespuestaDTO"] = new RespuestaDTO()
{
Exito = false, MensajesError = new List <string>()
{
"Los tickets no pertenecer al mismo cliente."
}
};
return(RedirectToAction("Index", _mod));
}
}
ViewBag.EsGenerico = "false";
ClientesModel Cliente = CatalogoServicio.ObtenerCliente(idCliente);
if (Cliente.Rfc.Equals("XAXX010101000"))
{
ViewBag.EsGenerico = "true";
Cliente = new ClientesModel();
}
TempData["FacturacionModel"] = _mod;
TempData["List<VentaPuntoVentaDTO>"] = _mod.Tickets;
ViewBag.Paises = CatalogoServicio.GetPaises();
ViewBag.Estados = CatalogoServicio.GetEstados();
ViewBag.TipoPersona = CatalogoServicio.ObtenerTiposPersona();
ViewBag.Regimen = CatalogoServicio.ObtenerRegimenFiscal();
if (Cliente.Locaciones != null && Cliente.Locaciones.Count > 0)
{
Cliente.Locacion = Cliente.Locaciones[0];
}
return(View("Facturar", Cliente));
}
public RespuestaDTO <TotalVentasAlmacenesDTO> getVentas(SolicitudReporteDTO solicitud)
{
RespuestaDTO <TotalVentasAlmacenesDTO> response = new RespuestaDTO <TotalVentasAlmacenesDTO>();
try {
TotalVentasAlmacenesDTO totalVentas = new TotalVentasAlmacenesDTO();
List <TotalVentasAlmacenDTO> ventas = new List <TotalVentasAlmacenDTO>();
foreach (AlmacenDTO almacen in solicitud.ListadoAlmacenes)
{
TotalVentasAlmacenDTO ventasAlmacen = new TotalVentasAlmacenDTO();
List <DatosVentasDto> cierres = new List <DatosVentasDto>();
ventasAlmacen.Almacen = almacen;
var query = db.Cierres.Where(cierre => cierre.Fecha <= solicitud.FechaFin && cierre.Fecha >= solicitud.FechaIni && cierre.AlmacenId == almacen.AlmacenId).OrderBy(c => c.Fecha).ToList <Cierre>();
foreach (Cierre c in query)
{
cierres.Add(new DatosVentasDto
{
Fecha = c.Fecha.ToShortDateString(),
Venta = c.Bancos + c.Efectivo,
Bancos = c.Bancos,
Efectivo = c.Efectivo,
});
ventasAlmacen.TotalBancos += c.Bancos;
ventasAlmacen.TotalEfectivo += c.Efectivo;
ventasAlmacen.TotalVentas += c.Bancos + c.Efectivo;
}
totalVentas.TotalBancos += ventasAlmacen.TotalBancos;
totalVentas.TotalEfectivo += ventasAlmacen.TotalEfectivo;
totalVentas.TotalVentas += ventasAlmacen.TotalVentas;
ventasAlmacen.ventas = cierres;
ventas.Add(ventasAlmacen);
}
totalVentas.ventasPorAlmacen = ventas;
response.Data = totalVentas;
response.Mensagge = "Consulta Realizada Con Exito";
return(response);
}
catch (Exception e) {
response.Mensagge = "Se Ha Presentado Un Error";
response.Errors.Add(new ResponseErrorDTO("500", e.Message));
return(response);
}
}
public RespuestaDTO <CierreDTO> InsertarCierre(CierreDTO cierre)
{
using (db = new Contexto())
{
RespuestaDTO <CierreDTO> response = new RespuestaDTO <CierreDTO>();
try
{
// preparar el cliente para guardar
Cierre cierreDal = new Cierre();
var qCietre = db.Cierres.Where(q => q.Fecha == cierre.Fecha && q.AlmacenId == cierre.AlmacenId).FirstOrDefault <Cierre>();
if (qCietre != null)
{
response.Mensagge = "Ya se Ha Registrado Un Cierre Para Esta Fecha Del Almacen";
response.Errors.Add(new ResponseErrorDTO("", "Fecha: " + qCietre.Fecha.ToString("dd/MM/yyyy") + " Almacen Id: " + qCietre.AlmacenId + " Ya Registra Un Cierre"));
return(response);
}
cierreDal.Bancos = cierre.Bancos;
cierreDal.Efectivo = cierre.Efectivo;
cierreDal.AlmacenId = cierre.AlmacenId;
cierreDal.Facturas = cierre.Facturas;
cierreDal.Invercion = cierre.Costos;
cierreDal.Costos = cierre.Gastos;
cierreDal.Fecha = cierre.Fecha;
db.Cierres.Add(cierreDal);
// preparar la respuesta
response.Rows = db.SaveChanges();
response.Mensagge = "Se Registro el Cierre satisfactoriamente";
response.Data = cierre;
}
catch (System.Data.Entity.Validation.DbEntityValidationException ex)
{
response.Mensagge = "Se Ha Presentado Un Error Al Guardar El Almacen";
response.Errors.Add(new ResponseErrorDTO(ex.GetHashCode().ToString(), ex.Message));
return(response);
}
catch (Exception ex)
{
response.Mensagge = "Se Ha Presentado Un Error";
response.Errors.Add(new ResponseErrorDTO(ex.GetHashCode().ToString(), ex.Message));
}
return(response);
}
}
public static RespuestaDTO FinalizarRevision(RequisicionRevisionModel model, string _tok)
{
List <RequisicionProdReviPutDTO> lProd = new List <RequisicionProdReviPutDTO>();
var valid = ValidarRevisionAlmacen(model, out lProd);
if (valid.Exito)
{
RequisicionRevPutDTO dto = RequisicionRevisionDTO(model, _tok, lProd);
RespuestaDTO resp = new RespuestaDTO();
return(ActualizarRequisicionRevision(dto, _tok));
}
else
{
return(valid);
}
}
public async Task <IHttpActionResult> Create(CreateRoleBindingModel model)
{
RespuestaDTO <RoleDTO> result = await new RoleBLL(Request).Create(new RoleDTO()
{
Name = model.Name
});
if (result.Error.Count > 0)
{
return(GetErrorResult(result));
}
Uri locationHeader = new Uri(Url.Link("GetRoleById", new { id = result.Data.Id }));
return(Created(locationHeader, result));
}
public RespuestaDTO <TotalGastosAlmacenes> getGastos(SolicitudReporteDTO solicitud)
{
RespuestaDTO <TotalGastosAlmacenes> response = new RespuestaDTO <TotalGastosAlmacenes>();
try
{
TotalGastosAlmacenes totalGastos = new TotalGastosAlmacenes();
List <TotalGastosAlmacen> gastos = new List <TotalGastosAlmacen>();
foreach (AlmacenDTO almacen in solicitud.ListadoAlmacenes)
{
TotalGastosAlmacen costosAlmacen = new TotalGastosAlmacen();
List <DatosGastosDTO> cierres = new List <DatosGastosDTO>();
costosAlmacen.Almacen = almacen;
var query = db.Cierres.Where(cierre => cierre.Fecha <= solicitud.FechaFin && cierre.Fecha >= solicitud.FechaIni && cierre.AlmacenId == almacen.AlmacenId).OrderBy(c => c.Fecha).ToList <Cierre>();
foreach (Cierre c in query)
{
cierres.Add(new DatosGastosDTO
{
Fecha = c.Fecha.ToShortDateString(),
Gastos = c.Costos
});
costosAlmacen.TotalGastos += c.Costos;
}
totalGastos.TotalGastos += costosAlmacen.TotalGastos;
costosAlmacen.Gastos = cierres;
gastos.Add(costosAlmacen);
}
totalGastos.CostosPorAlmacen = gastos;
response.Data = totalGastos;
response.Mensagge = "Consulta Realizada Con Exito";
return(response);
}
catch (Exception e)
{
response.Mensagge = "Se Ha Presentado Un Error";
response.Errors.Add(new ResponseErrorDTO("500", e.Message));
return(response);
}
}
public IHttpActionResult Consultar_Mecanicos()
{
var IOperacion = GeneradorOperacionBL.InstanciarClase(Enumeradores.clases.MecanicoBL.ToStringAttribute());
RespuestaDTO response = IOperacion.EjecutarOperacion(Enumeradores.clases.MecanicoBL.ToStringAttribute(), System.Reflection.MethodBase.GetCurrentMethod().Name, null);
if (response.Exito && response.Mecanicos.IsNullOrEmpty())
{
return(Ok(new RespuestaDTO()
{
Exito = true,
Mensaje = "No se encontro Información",
}));
}
else
{
return(Ok(response));
}
}
