public async Task <IActionResult> PutTodoItem(long id, TodoItem todoItem)
{
if (id != todoItem.Id)
{
return(BadRequest());
}
_context.Entry(todoItem).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!TodoItemExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
/// <summary>
/// Inserta un registro de Producto en base de datos
/// </summary>
/// <param name="Producto">Objeto de tipo Producto con la información ingresada</param>
/// <returns>Variable de tipo entero indicando el identificador de Producto si se insertó correctamente</returns>
public async Task <long> AgregaProductoJsonAsync(Producto producto)
{
long resultado = 0;
try
{
var itemProducto = new CtProducto
{
SKU = producto.SKU,
Descripcion = producto.Descripcion,
PrecioVenta = producto.PrecioVenta,
Costo = producto.Costo,
Imagen = producto.Imagen,
FKIdProveedor = producto.IdProveedor,
FKIdCategoria = producto.IdCategoria,
FKIdMarca = producto.IdMarca,
FKIdUnidadMedida = producto.IdUnidadMedida,
Activo = producto.Activo
};
context.CtProducto.Add(itemProducto);
await context.SaveChangesAsync();
resultado = itemProducto.PKIdProducto;
}
catch (Exception e)
{
var message = $"Ocurrió un error al registrar la Producto : {producto.Descripcion}";
throw new IOException(message, e);
}
return(resultado);
}
/// <summary>
/// Inserta un registro de Orden en base de datos
/// </summary>
/// <param name="Orden">Objeto de tipo Orden con la información ingresada</param>
/// <returns>Variable de tipo entero indicando el identificador de Orden si se insertó correctamente</returns>
public async Task <long> AgregaOrdenJsonAsync(Orden Orden)
{
long resultado = 0;
try
{
var itemOrden = new TbOrden
{
Fecha = Orden.Fecha,
Total = Orden.Total,
FKIdMetodoPago = Orden.IdMetodoPago,
FKIdEstatus = Orden.IdEstatus,
FKIdUsuario = Orden.IdUsuario
};
context.TbOrden.Add(itemOrden);
await context.SaveChangesAsync();
resultado = itemOrden.PKIdOrden;
}
catch (Exception e)
{
var message = $"Ocurrió un error al registrar la Orden";
throw new IOException(message, e);
}
return(resultado);
}
public async Task <IActionResult> PutRecipe(int id, Recipe recipe)
{
if (id != recipe.Id)
{
return(BadRequest());
}
_context.Entry(recipe).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!RecipeExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
/// <summary>
/// Inserta un registro de OrdenProducto en base de datos
/// </summary>
/// <param name="OrdenProducto">Objeto de tipo OrdenProducto con la información ingresada</param>
/// <returns>Variable de tipo entero indicando el identificador de OrdenProducto si se insertó correctamente</returns>
public async Task <long> AgregaOrdenProductoJsonAsync(OrdenProducto OrdenProducto)
{
long resultado = 0;
try
{
var itemOrdenProducto = new TbOrdenProducto
{
FKIdOrden = OrdenProducto.IdOrden,
FKIdProducto = OrdenProducto.IdProducto,
Cantidad = OrdenProducto.Cantidad,
Activo = OrdenProducto.Activo
};
context.TbOrdenProducto.Add(itemOrdenProducto);
await context.SaveChangesAsync();
resultado = itemOrdenProducto.PKIdOrdenProducto;
}
catch (Exception e)
{
var message = $"Ocurrió un error al registrar la OrdenProducto";
throw new IOException(message, e);
}
return(resultado);
}
public async Task <IActionResult> Create([Bind("BancoId,BancoNome")] Banco banco)
{
if (ModelState.IsValid)
{
_context.Add(banco);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(banco));
}
public async Task <IActionResult> Create([Bind("BancoContaId,ContaNumero,ContaSeguradora,BancoId,BRFSC")] BancoConta bancoConta)
{
if (ModelState.IsValid)
{
_context.Add(bancoConta);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(bancoConta));
}
public async Task <Tasks> Add(Tasks task)
{
await _context.Tasks.AddAsync(task);
await _context.SaveChangesAsync();
if (await _context.Tasks.ContainsAsync(task))
{
return(task);
}
return(null);
}
public async Task <ActionResult <Usuario> > CreateUsuario(Usuario usuario)
{
context.Usuarios.Add(usuario);
await context.SaveChangesAsync();
/**
* CreatedAtAction
* 1º - Retorna STATUSCODE = 201 e adiciona ao Location a resposta
* 2º - Refencia a ação GetUsuario
* 3º - retorna usuário no qual usuario.include == id
*/
return(CreatedAtAction(nameof(GetUsuario),
new { id = usuario.id },
usuario
));
}
/// <summary>
/// Returns a true/false if there was any changes to the DB.
/// </summary>
/// <returns>True / false</returns>
private async Task <bool> SaveDbAsync()
{
if (await _context.SaveChangesAsync() < 0)
{
return(true);
}
else
{
return(false);
}
}
public IHttpActionResult PostSite([FromBody] Website site)
{
List <Url> baseUrls = new List <Url>();
foreach (var item in dbCtx.Configurations)
{
baseUrls = item.Urls.Where(u => u.SiteCreationEnabled == true).ToList();
}
if (baseUrls.Count == 0)
{
return(this.InternalServerError(new Exception("No base url with site creation enabled could be found!")));
}
var realBaseUrl = (from u in baseUrls where u.Path.Equals(site.BaseUrl, StringComparison.InvariantCultureIgnoreCase) select u).ToList();
if (realBaseUrl.Count > 1)
{
return(this.InternalServerError(new Exception("Multiple matched base urls found! Please specify only one base url!")));
}
// :)
Url realRealBaseUrl = realBaseUrl.First();
using (ClientContext ctx = new ClientContext(realRealBaseUrl.Path))
{
ICredentials credentials;
if (realRealBaseUrl.IsOffice365)
{
credentials = CredentialManager.GetSharePointOnlineCredential("rmumsdn");
}
else
{
credentials = CredentialManager.GetCredential("vdrmu009");
}
if (credentials == null)
{
return(this.InternalServerError(new Exception("No valid credentials found!")));
}
ctx.Credentials = credentials;
Microsoft.Online.SharePoint.TenantAdministration.Tenant tenant = new Microsoft.Online.SharePoint.TenantAdministration.Tenant(ctx);
site.ID = tenant.CreateSiteCollection(site.Url, site.Title, site.OwnerLogin,
site.Type == WebsiteType.Collaboration ? "STS#0" : "STS#0",
100, 90, 3, 50, 40, site.Locale);
ctx.ExecuteQuery();
}
dbCtx.Websites.Add(site);
dbCtx.SaveChangesAsync();
return(Ok(site.ID));
}
/// <summary>
/// Inserta un registro de RolPermiso en base de datos
/// </summary>
/// <param name="RolPermiso">Objeto de tipo RolPermiso con la información ingresada</param>
/// <returns>Variable de tipo entero indicando el identificador de RolPermiso si se insertó correctamente</returns>
public async Task <long> AgregaRolPermisoJsonAsync(RolPermiso rolPermiso)
{
long resultado = 0;
try
{
//Consulta para obtener RolPermiso
TbRolPermiso objRolPermiso = context.TbRolPermiso.Where(x => x.FKIdRol == rolPermiso.IdRol && x.FKIdPermiso == rolPermiso.IdPermiso).FirstOrDefault();
if (objRolPermiso == null)
{
var itemRolPermiso = new TbRolPermiso
{
FKIdRol = rolPermiso.IdRol,
FKIdPermiso = rolPermiso.IdPermiso,
Activo = rolPermiso.Activo
};
context.TbRolPermiso.Add(itemRolPermiso);
await context.SaveChangesAsync();
resultado = itemRolPermiso.PKIdRolPermiso;
}
else
{
objRolPermiso.FKIdRol = rolPermiso.IdRol;
objRolPermiso.FKIdPermiso = rolPermiso.IdPermiso;
objRolPermiso.Activo = true;
await context.SaveChangesAsync();
resultado = objRolPermiso.PKIdRolPermiso;
}
}
catch (Exception e)
{
var message = $"Ocurrió un error al registrar el RolPermiso";
throw new IOException(message, e);
}
return(resultado);
}
public async Task <int> agregaTurnoJsonAsync(Turno turno)
{
int resultado;
try
{
var itemTurno = new TbTurno
{
IdUsuario = turno.IdUsuario,
FechaHoraApertura = Convert.ToDateTime(turno.FechaHoraApertura),
FechaHoraCierre = Convert.ToDateTime(turno.FechaHoraCierre),
FondoFijo = Convert.ToDecimal(turno.FondoFijo),
FondoVenta = Convert.ToDecimal(turno.FondoVenta),
TotalCierre = Convert.ToDecimal(turno.TotalCierre),
EntregaCompleta = turno.EntregaCompleta
};
context.TbTurno.Add(itemTurno);
resultado = await context.SaveChangesAsync();
foreach (Fondo fondo in turno.ItemsFondo)
{
var itemFondo = new TbFondo
{
FKIdDenominacion = fondo.IdDenominacion,
FKIdTipoMovimiento = fondo.IdTipoMovimiento,
FKIdTurno = itemTurno.PKIdTurno,
Cantidad = fondo.Cantidad
};
context.TbFondo.Add(itemFondo);
var res = await context.SaveChangesAsync();
}
}
catch (Exception e)
{
var message = $"Ocurrio un error al registrar el turno con Id de Usuario : {turno.IdUsuario}";
throw new IOException(message, e);
}
return(resultado);
}
/// <summary>
/// Inserta un registro de Categoria en base de datos
/// </summary>
/// <param name="Categoria">Objeto de tipo Categoria con la información ingresada</param>
/// <returns>Variable de tipo entero indicando el identificador de Categoria si se insertó correctamente</returns>
public async Task <long> AgregaCategoriaJsonAsync(Categoria Categoria)
{
long resultado = 0;
try
{
var itemCategoria = new CtCategoria
{
Descripcion = Categoria.Descripcion,
Activo = Categoria.Activo
};
context.CtCategoria.Add(itemCategoria);
await context.SaveChangesAsync();
resultado = itemCategoria.PKIdCategoria;
}
catch (Exception e)
{
var message = $"Ocurrió un error al registrar la Categoria : {Categoria.Descripcion}";
throw new IOException(message, e);
}
return(resultado);
}
/// <summary>
/// Inserta un registro de Permiso en base de datos
/// </summary>
/// <param name="Permiso">Objeto de tipo Permiso con la información ingresada</param>
/// <returns>Variable de tipo entero indicando el identificador de Permiso si se insertó correctamente</returns>
public async Task <long> AgregaPermisoJsonAsync(Permiso permiso)
{
long resultado = 0;
try
{
var itemPermiso = new CtPermiso
{
Descripcion = permiso.Descripcion,
Activo = permiso.Activo
};
context.CtPermiso.Add(itemPermiso);
await context.SaveChangesAsync();
resultado = itemPermiso.PKIdPermiso;
}
catch (Exception e)
{
var message = $"Ocurrió un error al registrar el Permiso : {permiso.Descripcion}";
throw new IOException(message, e);
}
return(resultado);
}
/// <summary>
/// Inserta un registro de Proveedor en base de datos
/// </summary>
/// <param name="Proveedor">Objeto de tipo Proveedor con la información ingresada</param>
/// <returns>Variable de tipo entero indicando el identificador de Proveedor si se insertó correctamente</returns>
public async Task <long> AgregaProveedorJsonAsync(Proveedor proveedor)
{
long resultado = 0;
try
{
var itemProveedor = new CtProveedor
{
Descripcion = proveedor.Descripcion,
Activo = proveedor.Activo
};
context.CtProveedor.Add(itemProveedor);
await context.SaveChangesAsync();
resultado = itemProveedor.PKIdProveedor;
}
catch (Exception e)
{
var message = $"Ocurrió un error al registrar la Proveedor : {proveedor.Descripcion}";
throw new IOException(message, e);
}
return(resultado);
}
/// <summary>
/// Inserta un registro de Estatus en base de datos
/// </summary>
/// <param name="Estatus">Objeto de tipo Estatus con la información ingresada</param>
/// <returns>Variable de tipo entero indicando el identificador de Estatus si se insertó correctamente</returns>
public async Task <long> AgregaEstatusJsonAsync(Estatus Estatus)
{
long resultado = 0;
try
{
var itemEstatus = new CtEstatus
{
Descripcion = Estatus.Descripcion,
Activo = Estatus.Activo
};
context.CtEstatus.Add(itemEstatus);
await context.SaveChangesAsync();
resultado = itemEstatus.PKIdEstatus;
}
catch (Exception e)
{
var message = $"Ocurrió un error al registrar la Estatus : {Estatus.Descripcion}";
throw new IOException(message, e);
}
return(resultado);
}
/// <summary>
/// Inserta un registro de UnidadMedida en base de datos
/// </summary>
/// <param name="UnidadMedida">Objeto de tipo UnidadMedida con la información ingresada</param>
/// <returns>Variable de tipo entero indicando el identificador de UnidadMedida si se insertó correctamente</returns>
public async Task <long> AgregaUnidadMedidaJsonAsync(UnidadMedida UnidadMedida)
{
long resultado = 0;
try
{
var itemUnidadMedida = new CtUnidadMedida
{
Descripcion = UnidadMedida.Descripcion,
Activo = UnidadMedida.Activo
};
context.CtUnidadMedida.Add(itemUnidadMedida);
await context.SaveChangesAsync();
resultado = itemUnidadMedida.PKIdUnidadMedida;
}
catch (Exception e)
{
var message = $"Ocurrió un error al registrar la UnidadMedida : {UnidadMedida.Descripcion}";
throw new IOException(message, e);
}
return(resultado);
}
/// <summary>
/// Inserta un registro de MetodoPago en base de datos
/// </summary>
/// <param name="MetodoPago">Objeto de tipo MetodoPago con la información ingresada</param>
/// <returns>Variable de tipo entero indicando el identificador de MetodoPago si se insertó correctamente</returns>
public async Task <long> AgregaMetodoPagoJsonAsync(MetodoPago MetodoPago)
{
long resultado = 0;
try
{
var itemMetodoPago = new CtMetodoPago
{
Descripcion = MetodoPago.Descripcion,
Activo = MetodoPago.Activo
};
context.CtMetodoPago.Add(itemMetodoPago);
await context.SaveChangesAsync();
resultado = itemMetodoPago.PKIdMetodoPago;
}
catch (Exception e)
{
var message = $"Ocurrió un error al registrar la MetodoPago : {MetodoPago.Descripcion}";
throw new IOException(message, e);
}
return(resultado);
}
/// <summary>
/// Inserta un registro de Marca en base de datos
/// </summary>
/// <param name="Marca">Objeto de tipo Marca con la información ingresada</param>
/// <returns>Variable de tipo entero indicando el identificador de Marca si se insertó correctamente</returns>
public async Task <long> AgregaMarcaJsonAsync(Marca Marca)
{
long resultado = 0;
try
{
var itemMarca = new CtMarca
{
Descripcion = Marca.Descripcion,
Activo = Marca.Activo
};
context.CtMarca.Add(itemMarca);
await context.SaveChangesAsync();
resultado = itemMarca.PKIdMarca;
}
catch (Exception e)
{
var message = $"Ocurrió un error al registrar la Marca : {Marca.Descripcion}";
throw new IOException(message, e);
}
return(resultado);
}
/// <summary>
/// Inserta un registro de Rol en base de datos
/// </summary>
/// <param name="Rol">Objeto de tipo Rol con la información ingresada</param>
/// <returns>Variable de tipo entero indicando el identificador de Rol si se insertó correctamente</returns>
public async Task <long> AgregaRolJsonAsync(Rol rol)
{
long resultado = 0;
try
{
var itemRol = new CtRol
{
Descripcion = rol.Descripcion,
Activo = rol.Activo
};
context.CtRol.Add(itemRol);
await context.SaveChangesAsync();
resultado = itemRol.PKIdRol;
}
catch (Exception e)
{
var message = $"Ocurrió un error al registrar el Rol : {rol.Descripcion}";
throw new IOException(message, e);
}
return(resultado);
}
public async Task <int> agregarUsuario(Usuario usuario)
{
int resultado;
try
{
var item = new CtUsuario
{
ClaveUsuario = usuario.ClaveUsuario,
Nombre = usuario.Nombre,
ApellidoPaterno = usuario.ApellidoPaterno,
ApellidoMaterno = usuario.ApellidoMaterno
};
context.CtUsuario.Add(item);
resultado = await context.SaveChangesAsync();
return(resultado);
}
catch (Exception ex)
{
return(0);
}
}