public async Task <IActionResult> PrestarInsumos(string prestamos, string documento)
{
if (User.Identity.IsAuthenticated)
{
string permiso = Permisos("PermisoSubModulo").PSMAPB ? "PermisoSubModulo" : "PermisoModulo";
bool crear = Permisos(permiso).PMMAPL.Where(w => w.Value.Contains("Crear")).Any();
if (crear)
{
dynamic prestamosJson = JsonConvert.DeserializeObject(prestamos);
List <Col_Prestamos> _prestamos = new List <Col_Prestamos>();
foreach (dynamic item in prestamosJson)
{
Col_Prestamos _prestamo = new Col_Prestamos();
_prestamo.Cantidad = item.Cantidad;
_prestamo.FechaPrestamo = Convert.ToDateTime(item.FechaPrestamo.ToString());
_prestamo.Motivo = item.Motivo;
_prestamo.SuministroId = item.SuministroId;
_prestamos.Add(_prestamo);
}
ApiCallResult data = await service.PrestarInsumos(_prestamos, documento);
return(Json(data));
}
else
{
return(NotFound());
}
}
else
{
return(RedirectToAction("Index", "Login"));
}
}
private async Task <ApiCallResult <T> > DoRequestAsync <T>(string method, string uri, string body, string mimeType) where T : class
{
HttpRequestMessage req = new HttpRequestMessage(new HttpMethod(method), uri);
if (body != null)
{
req.Content = new StringContent(body);
req.Content.Headers.ContentType = new System.Net.Http.Headers.MediaTypeHeaderValue(mimeType ?? "application/json");
}
HttpResponseMessage hrm = await client.SendAsync(req);
string responseBody = await hrm.Content.ReadAsStringAsync();
T obj = null;
string mType = hrm.Content.Headers.ContentType.MediaType?.ToLower();
if (!string.IsNullOrWhiteSpace(responseBody) && (mType == "application/json" || mType == "application/ld+json"))
{
obj = JsonConvert.DeserializeObject <T>(responseBody);
}
ApiCallResult <T> result = new ApiCallResult <T>((int)hrm.StatusCode, obj, responseBody, string.IsNullOrWhiteSpace(responseBody));
return(result);
}
public async Task <IActionResult> AgregarMateriasHorario(string horario)
{
if (User.Identity.IsAuthenticated)
{
string permiso = Permisos("PermisoSubModulo").PSMAPB ? "PermisoSubModulo" : "PermisoModulo";
bool crear = Permisos(permiso).PMMAPL.Where(w => w.Value.Contains("Crear")).Any();
if (crear)
{
dynamic horarioJson = JsonConvert.DeserializeObject(horario);
Col_Horarios _horario = new Col_Horarios();
_horario.MateriaId = horarioJson.MateriaId;
_horario.CursoId = horarioJson.CursoId;
_horario.HoraIni = horarioJson.HoraIni;
_horario.HoraFin = horarioJson.HoraFin;
ApiCallResult result = await service.AgregarMateriasHorario(_horario);
return(Json(result));
}
else
{
return(NotFound());
}
}
else
{
return(RedirectToAction("Index", "Login"));
}
}
public async Task <IActionResult> GuardarMarterias(string materia)
{
if (User.Identity.IsAuthenticated)
{
string permiso = Permisos("PermisoSubModulo").PSMAPB ? "PermisoSubModulo" : "PermisoModulo";
bool crear = Permisos(permiso).PMMAPL.Where(w => w.Value.Contains("Crear")).Any();
if (crear)
{
dynamic materiaJson = JsonConvert.DeserializeObject(materia);
Col_Materias _materia = new Col_Materias();
_materia.Codigo = materiaJson.Codigo;
_materia.Nombre = materiaJson.Nombre;
_materia.Color = materiaJson.Color;
_materia.Descripcion = materiaJson.Descripcion;
ApiCallResult result = await service.GuardarMaterias(_materia);
return(Json(result));
}
else
{
return(NotFound());
}
}
else
{
return(RedirectToAction("Index", "Login"));
}
}
public async Task <IActionResult> GuardarSuministros(string suministros)
{
if (User.Identity.IsAuthenticated)
{
string permiso = Permisos("PermisoSubModulo").PSMAPB ? "PermisoSubModulo" : "PermisoModulo";
bool crear = Permisos(permiso).PMMAPL.Where(w => w.Value.Contains("Crear")).Any();
if (crear)
{
dynamic suministroJson = JsonConvert.DeserializeObject(suministros);
Col_Suministros _suministro = new Col_Suministros();
_suministro.Descripcion = suministroJson.Descripcion;
_suministro.Nombre = suministroJson.Nombre;
_suministro.Stock = suministroJson.Stock;
_suministro.Talla = suministroJson.Talla;
_suministro.Linea = suministroJson.Linea;
_suministro.TipoSuministro = suministroJson.TipoSuministro;
ApiCallResult result = await service.GuardarSuministros(_suministro);
return(Json(result));
}
else
{
return(NotFound());
}
}
else
{
return(RedirectToAction("Index", "Login"));
}
}
public async Task <IActionResult> DevolverInsumos(string devoluciones)
{
if (User.Identity.IsAuthenticated)
{
string permiso = Permisos("PermisoSubModulo").PSMAPB ? "PermisoSubModulo" : "PermisoModulo";
bool crear = Permisos(permiso).PMMAPL.Where(w => w.Value.Contains("Crear")).Any();
if (crear)
{
dynamic devolucionJson = JsonConvert.DeserializeObject(devoluciones);
List <Devoluciones> _devoluciones = new List <Devoluciones>();
foreach (dynamic item in devolucionJson)
{
Devoluciones _devolucion = new Devoluciones();
_devolucion.IdPersona = item.idPersona;
_devolucion.IdPrestamo = item.idPrestamo;
_devolucion.Devolver = item.incremento;
_devolucion.SuministroId = item.suministroId;
_devolucion.Cantidad = item.cantidadActual;
_devoluciones.Add(_devolucion);
}
ApiCallResult insumos = await service.DevolverInsumos(_devoluciones);
return(Json(insumos));
}
else
{
return(NotFound());
}
}
else
{
return(RedirectToAction("Index", "Login"));
}
}
private async Task GetTransactionPositionsBySingleAddress(string paymentAddress, SortedSet <Tuple <Int64, string> > txPositions, Stopwatch stopWatch)
{
Utils.CheckIfChainIsFresh(chain_, config_.AcceptStaleRequests);
using (var address = new PaymentAddress(paymentAddress))
{
//Unconfirmed first
GetUnconfirmedTransactionPositions(address, txPositions);
//3
statsGetTransactions.Add(stopWatch.ElapsedMilliseconds);
using (var getTransactionResult = await chain_.FetchConfirmedTransactionsAsync(address, UInt64.MaxValue, 0))
{
Utils.CheckBitprimApiErrorCode(getTransactionResult.ErrorCode, "FetchConfirmedTransactionsAsync(" + paymentAddress + ") failed, check error log.");
//4
statsGetTransactions.Add(stopWatch.ElapsedMilliseconds);
INativeList <byte[]> confirmedTxIds = getTransactionResult.Result;
//Confirmed
foreach (byte[] txHash in confirmedTxIds)
{
ApiCallResult <GetTxPositionResult> getTxPosResult = await chain_.FetchTransactionPositionAsync(txHash, true);
string txHashStr = Binary.ByteArrayToHexString(txHash);
Utils.CheckBitprimApiErrorCode(getTxPosResult.ErrorCode, "FetchTransactionPositionAsync(" + txHashStr + ") failed, check error log");
txPositions.Add(new Tuple <Int64, string>((Int64)getTxPosResult.Result.BlockHeight, txHashStr));
}
//5
statsGetTransactions.Add(stopWatch.ElapsedMilliseconds);
}
}
}
public async Task <ActionResult> GetBlockByHash(string hash, int noTxList = 1)
{
if (!Validations.IsValidHash(hash))
{
return(BadRequest(hash + " is not a valid block hash"));
}
Utils.CheckIfChainIsFresh(chain_, config_.AcceptStaleRequests);
string key = "block" + noTxList + hash;
if (memoryCache_.TryGetValue(key, out JsonResult cachedBlockJson))
{
return(cachedBlockJson);
}
;
var binaryHash = Binary.HexStringToByteArray(hash);
using (DisposableApiCallResult <GetBlockHeaderByHashTxSizeResult> getBlockResult = await chain_.FetchBlockHeaderByHashTxSizesAsync(binaryHash))
{
Utils.CheckBitprimApiErrorCode(getBlockResult.ErrorCode, "FetchBlockHeaderByHashTxSizesAsync(" + hash + ") failed, check error log");
var getLastHeightResult = await chain_.FetchLastHeightAsync();
Utils.CheckBitprimApiErrorCode(getLastHeightResult.ErrorCode, "FetchLastHeightAsync() failed, check error log");
var blockHeight = getBlockResult.Result.Header.BlockHeight;
ApiCallResult <GetBlockHashTimestampResult> getNextBlockResult = null;
if (blockHeight != getLastHeightResult.Result)
{
getNextBlockResult = await chain_.FetchBlockByHeightHashTimestampAsync(blockHeight + 1);
Utils.CheckBitprimApiErrorCode(getNextBlockResult.ErrorCode, "FetchBlockByHeightHashTimestampAsync(" + blockHeight + 1 + ") failed, check error log");
}
decimal blockReward;
PoolInfo poolInfo;
using (DisposableApiCallResult <GetTxDataResult> coinbase = await chain_.FetchTransactionAsync(getBlockResult.Result.TransactionHashes[0], true))
{
Utils.CheckBitprimApiErrorCode(coinbase.ErrorCode, "FetchTransactionAsync(" + getBlockResult.Result.TransactionHashes[0] + ") failed, check error log");
blockReward = Utils.SatoshisToCoinUnits(coinbase.Result.Tx.TotalOutputValue);
poolInfo = poolsInfo_.GetPoolInfo(coinbase.Result.Tx);
}
JsonResult blockJson = Json(BlockToJSON
(
getBlockResult.Result.Header.BlockData, blockHeight, getBlockResult.Result.TransactionHashes,
blockReward, getLastHeightResult.Result, getNextBlockResult?.Result.BlockHash,
getBlockResult.Result.SerializedBlockSize, poolInfo, noTxList == 0)
);
memoryCache_.Set(key, blockJson, new MemoryCacheEntryOptions {
Size = Constants.Cache.BLOCK_CACHE_ENTRY_SIZE
});
return(blockJson);
}
}
protected override async Task OnInitializedAsync()
{
NewItem = new ItemCreateApiModel();
ApiCallResult <IList <ItemApiModel> > apiCallResult = await AppHttpClient.GetAsync <IList <ItemApiModel> >(ApiUrls.GetItemsList);
Items = apiCallResult.IsSuccess
? apiCallResult.Value !
: throw new Exception("API call is not successful");
}
private async Task <TransactionSummary> TxToJSON(ITransaction tx, UInt64 blockHeight, bool confirmed,
bool returnLegacyAddresses, bool noAsm, bool noScriptSig,
bool noSpend)
{
UInt32 blockTimestamp = 0;
string blockHash = "";
if (confirmed)
{
using (var getBlockHeaderResult = await chain_.FetchBlockHeaderByHeightAsync(blockHeight))
{
Utils.CheckBitprimApiErrorCode(getBlockHeaderResult.ErrorCode, "FetchBlockHeaderByHeightAsync(" + blockHeight + ") failed, check error log");
IHeader blockHeader = getBlockHeaderResult.Result.BlockData;
blockTimestamp = blockHeader.Timestamp;
blockHash = Binary.ByteArrayToHexString(blockHeader.Hash);
}
}
ApiCallResult <UInt64> getLastHeightResult = await chain_.FetchLastHeightAsync();
Utils.CheckBitprimApiErrorCode(getLastHeightResult.ErrorCode, "FetchLastHeightAsync failed, check error log");
var txJson = new TransactionSummary();
txJson.txid = Binary.ByteArrayToHexString(tx.Hash);
txJson.version = tx.Version;
txJson.locktime = tx.Locktime;
txJson.vin = await TxInputsToJSON(tx, returnLegacyAddresses, noAsm, noScriptSig);
txJson.vout = await TxOutputsToJSON(tx, returnLegacyAddresses, noAsm, noSpend);
txJson.confirmations = confirmed? getLastHeightResult.Result - blockHeight + 1 : 0;
txJson.isCoinBase = tx.IsCoinbase;
txJson.valueOut = Utils.SatoshisToCoinUnits(tx.TotalOutputValue);
txJson.size = tx.GetSerializedSize();
UInt64 inputsTotal = await ManuallyCalculateInputsTotal(tx); //TODO Solve at native layer
txJson.valueIn = Utils.SatoshisToCoinUnits(inputsTotal);
if (confirmed)
{
txJson.blockhash = blockHash;
txJson.time = blockTimestamp;
txJson.blocktime = blockTimestamp;
txJson.blockheight = (Int64)blockHeight;
}
else
{
txJson.blockheight = -1;
txJson.time = (UInt32)DateTimeOffset.UtcNow.ToUnixTimeSeconds();
}
if (!tx.IsCoinbase)
{
txJson.fees = Utils.SatoshisToCoinUnits(inputsTotal - tx.TotalOutputValue); //TODO Solve at native layer
}
return(txJson);
}
public IActionResult GuardarComentario(ComentarioSavedDto comentarioDto)
{
try
{
ApiCallResult result = this.blogService.GuardarComentario(comentarioDto);
return(Json(result));
}
catch (Exception e)
{
return(StatusCode((int)System.Net.HttpStatusCode.InternalServerError, e.Message));
}
}
public IActionResult GuardarContenido(PrincipalDto principalDto)
{
try
{
ApiCallResult result = this.principalService.GuardarContenido(principalDto);
return(Json(result));
}
catch (Exception e)
{
return(StatusCode((int)System.Net.HttpStatusCode.InternalServerError, e.Message));
}
}
/// <summary>
/// Obtain an auth token using a username and password. Will automatically set this <see cref="BadgrClient"/>'s auth token if login is successful.
/// </summary>
/// <param name="username">Username or email</param>
/// <param name="password">Password</param>
/// <returns>An <see cref="AuthResponse"/> possibly containing an auth token.</returns>
public async Task <ApiCallResult <AuthResponse> > AuthenticateAsync(string username, string password)
{
string uri = $"{Endpoints.API_AUTH}{Endpoints.API_TOKEN}";
string body = $"username={username}&password={password}";
string mime = "application/x-www-form-urlencoded";
ApiCallResult <AuthResponse> res = await DoPostAsync <AuthResponse>(uri, mime, body);
if (res.Success)
{
SetAuthToken(res.Result.access_token, res.Result.refresh_token);
}
return(res);
}
/// <summary>
/// Refreshes an auth token. Set the token to refresh using <see cref="SetAuthToken(string)"/>
/// </summary>
/// <param name="refreshToken">The refresh token, used to refresh the bearer token</param>
/// <returns></returns>
public async Task <ApiCallResult <AuthResponse> > RefreshAuthTokenAsync(string refreshToken)
{
string url = $"{Endpoints.API_AUTH}{Endpoints.API_TOKEN}";
string body = $"grant_type=refresh_token&refresh_token={refreshToken}";
string mime = "application/x-www-form-urlencoded";
ApiCallResult <AuthResponse> res = await DoPostAsync <AuthResponse>(url, mime, body);
if (res.Success)
{
SetAuthToken(res.Result.access_token, res.Result.refresh_token);
}
return(res);
}
public async Task <IActionResult> GuardarCuenta(string nombre, string titular, string numero)
{
if (User.Identity.IsAuthenticated)
{
string permiso = Permisos("PermisoSubModulo").PSMAPB ? "PermisoSubModulo" : "PermisoModulo";
bool crear = Permisos(permiso).PMMAPL.Where(w => w.Value.Contains("Crear")).Any();
if (crear)
{
ApiCallResult result = await service.GuardarCuenta(nombre, titular, numero);
return(Json(result));
}
return(RedirectToAction("Index", "Home"));
}
return(RedirectToAction("Index", "Login"));
}
protected override async Task HandleEventAsync()
{
if (!string.IsNullOrWhiteSpace(NewItem.Text))
{
ApiCallResult <ItemApiModel> itemCreationCallResult = await AppHttpClient
.PostAsync <ItemApiModel>(ApiUrls.CreateItem, NewItem);
Items.Add(
itemCreationCallResult.IsSuccess
? itemCreationCallResult.Value !
: throw new Exception("API call is not successful")
);
NewItem.Text = string.Empty;
}
}
public IActionResult GuardarEntradaYoutube(EntradaYoutubeDto youtubeDto)
{
try
{
ApiCallResult result = this.service.GuardarEntradaYoutube(youtubeDto);
return(StatusCode((int)System.Net.HttpStatusCode.OK, result));
}
catch (NegocioExecption e)
{
return(StatusCode((int)System.Net.HttpStatusCode.NotFound, e.Message));
}
catch (Exception e)
{
return(StatusCode((int)System.Net.HttpStatusCode.InternalServerError, e.Message));
}
}
public IActionResult GuardarKeyWords(KeyWordDto keyWordDto)
{
try
{
ApiCallResult result = this.blogService.GuardarKeyWord(keyWordDto.Nombre);
return(StatusCode((int)System.Net.HttpStatusCode.OK, result));
}
catch (NegocioExecption e)
{
return(StatusCode((int)System.Net.HttpStatusCode.NotFound, e.Message));
}
catch (Exception e)
{
return(StatusCode((int)System.Net.HttpStatusCode.InternalServerError, e.Message));
}
}
public IActionResult ActualizarEntradaPost(BlogDetalleDto blogDto)
{
try
{
ApiCallResult result = this.podcastService.ActualizarEntradaPost(blogDto);
return(StatusCode((int)System.Net.HttpStatusCode.OK, result));
}
catch (NegocioExecption e)
{
return(StatusCode((int)System.Net.HttpStatusCode.NotFound, e.Message));
}
catch (Exception e)
{
return(StatusCode((int)System.Net.HttpStatusCode.InternalServerError, e.Message));
}
}
public IActionResult EliminarEntradaYoutube(string slug)
{
try
{
ApiCallResult result = this.podcastService.EliminarEntradaPodcast(slug);
return(StatusCode((int)System.Net.HttpStatusCode.OK, result));
}
catch (NegocioExecption e)
{
return(StatusCode((int)System.Net.HttpStatusCode.NotFound, e.Message));
}
catch (Exception e)
{
return(StatusCode((int)System.Net.HttpStatusCode.InternalServerError, e.Message));
}
}
public async Task <IActionResult> GuardarCambios(string modulo, string subModulo, string rol, string descripcion, int idRol)
{
if (User.Identity.IsAuthenticated)
{
string permiso = Permisos("PermisoSubModulo").PSMAPB ? "PermisoSubModulo" : "PermisoModulo";
bool crear = Permisos(permiso).PMMAPL.Where(w => w.Value.Contains("Crear")).Any();
bool actualizar = Permisos(permiso).PMMAPL.Where(w => w.Value.Contains("Actualizar")).Any();
if ((crear && idRol == 0) || (actualizar && idRol != 0))
{
dynamic moduloJson = JsonConvert.DeserializeObject(modulo);
dynamic subModuloJson = JsonConvert.DeserializeObject(subModulo);
List <Col_RolModulos> modulos = new List <Col_RolModulos>();
List <Col_SubModuloModulo> subModulos = new List <Col_SubModuloModulo>();
foreach (dynamic item in moduloJson)
{
Col_RolModulos _modulo = new Col_RolModulos();
_modulo.ModuloId = item.ModuloId;
_modulo.PermisosCrud = item.PermisosCrud;
modulos.Add(_modulo);
}
if (subModuloJson.Count > 0)
{
foreach (dynamic item in subModuloJson)
{
Col_SubModuloModulo _subModulos = new Col_SubModuloModulo();
_subModulos.SubModuloId = item.SubModuloId;
_subModulos.ModuloId = item.ModuloId;
_subModulos.PermisosCrud = item.PermisosCrud;
subModulos.Add(_subModulos);
}
}
ApiCallResult result = idRol == 0 ? await service.GuardarAutorizaciones(modulos, subModulos, rol, descripcion) :
await service.ActualizarAutorizaciones(modulos, subModulos, rol, descripcion, idRol);
return(Json(new { result }));
}
else
{
return(NotFound());
}
}
else
{
return(RedirectToAction("Index", "Login"));
}
}
public IActionResult GuardarPodcast(BlogDetalleDto blogDto)
{
try
{
ApiCallResult result = this.podcastService.GuardarPodcast(blogDto);
return(Ok(new
{
response = result,
}));
}
catch (NegocioExecption e)
{
return(StatusCode(e.Codigo, e.Message));
}
catch (Exception e)
{
return(StatusCode((int)System.Net.HttpStatusCode.InternalServerError, e.Message));
}
}
public async Task <IActionResult> AgregarEnlaceProfesorHorario(int idHorario, string documento)
{
if (User.Identity.IsAuthenticated)
{
string permiso = Permisos("PermisoSubModulo").PSMAPB ? "PermisoSubModulo" : "PermisoModulo";
bool crear = Permisos(permiso).PMMAPL.Where(w => w.Value.Contains("Crear")).Any();
if (crear)
{
ApiCallResult result = await service.AgregarEnlaceProfesorHorario(idHorario, documento);
return(Json(result));
}
else
{
return(NotFound());
}
}
else
{
return(RedirectToAction("Index", "Login"));
}
}
public async Task <IActionResult> EliminarSuministros(int suministroId)
{
if (User.Identity.IsAuthenticated)
{
string permiso = Permisos("PermisoSubModulo").PSMAPB ? "PermisoSubModulo" : "PermisoModulo";
bool eliminar = Permisos(permiso).PMMAPL.Where(w => w.Value.Contains("Eliminar")).Any();
if (eliminar)
{
ApiCallResult insumos = await service.EliminarSuministros(suministroId);
return(Json(insumos));
}
else
{
return(NotFound());
}
}
else
{
return(RedirectToAction("Index", "Login"));
}
}
public async Task <IActionResult> ActivarEmpleado(int personaId)
{
if (User.Identity.IsAuthenticated)
{
string permiso = Permisos("PermisoSubModulo").PSMAPB ? "PermisoSubModulo" : "PermisoModulo";
bool actualizar = Permisos(permiso).PMMAPL.Where(w => w.Value.Contains("Actualizar")).Any();
if (actualizar)
{
ApiCallResult result = await service.ActivarPerfil(personaId);
return(Json(result));
}
else
{
return(NotFound());
}
}
else
{
return(RedirectToAction("Index", "Login"));
}
}
public async Task <IActionResult> GuardarAfiliacion(string afiliaciones, int rol, int laboralId, string persona, int afiliacioneActualizar)
{
if (User.Identity.IsAuthenticated)
{
string permiso = Permisos("PermisoSubModulo").PSMAPB ? "PermisoSubModulo" : "PermisoModulo";
bool crear = Permisos(permiso).PMMAPL.Where(w => w.Value.Contains("Crear")).Any();
bool Actualizar = Permisos(permiso).PMMAPL.Where(w => w.Value.Contains("Actualizar")).Any();
if (crear || (Actualizar && afiliacioneActualizar != 0))
{
dynamic afiliacionesJson = JsonConvert.DeserializeObject(afiliaciones);
dynamic personaJson = JsonConvert.DeserializeObject(persona);
Col_Personas _persona = new Col_Personas();
_persona.TipoDocumento = personaJson.TipoDocumento;
_persona.PrimerNombre = personaJson.PrimerNombre;
_persona.PrimerApellido = personaJson.PrimerApellido;
_persona.NumeroDocumento = personaJson.NumeroDocumento;
List <Col_Afiliacion> _afiliaciones = new List <Col_Afiliacion>();
foreach (dynamic item in afiliacionesJson)
{
Col_Afiliacion afiliacion = new Col_Afiliacion();
afiliacion.FechaAfiliacion = Convert.ToDateTime(item.FechaAfiliacion.ToString());
afiliacion.NombreEntidad = item.NombreEntidad;
afiliacion.TipoEntidad = item.TipoEntidad;
_afiliaciones.Add(afiliacion);
}
ApiCallResult result = afiliacioneActualizar == 0 ? await service.GuardarAfiliacion(_afiliaciones, rol, laboralId, _persona)
: await service.ActualizarAfiliciacion(_afiliaciones, afiliacioneActualizar);
return(Json(result));
}
return(RedirectToAction("Index", "Home"));
}
return(RedirectToAction("Index", "Login"));
}
private void AssertPushNotificationReturnedInfo(AppleApiNotificationPayLoad payLoad, ApiCallResult result)
{
var pushResult = result as PushNotificationApiCallResult;
Assert.AreEqual(payLoad.DeviceUuid, pushResult.DeviceUuid);
Assert.AreEqual(payLoad.Message, pushResult.NotificationMessage);
}
