public async void UploadContentCreatorCover(string path, int idContentCreator)
{
var channel = new Channel(Configuration.URIGrpcServer, ChannelCredentials.Insecure);
var client = new Portadas.PortadasClient(channel);
var call = client.SubirPortadaCreadorDeContenido();
for (var i = 1; i <= TryNumbres; i++)
{
try
{
var response = await UploadCover(path, idContentCreator, call);
if (response.Error == Error.TokenInvalido || response.Error == Error.TokenFaltante)
{
await ApiServiceLogin.GetServiceLogin().ReLogin();
}
else if (response.Error == Error.Ninguno)
{
break;
}
else
{
ErrorHandlerUploadCover(response);
}
}
catch (RpcException ex)
{
throw new RpcException(ex.Status, ex.Message);
}
}
}
/// <summary>
/// Recupera el usuario logeado y lo asigna a la variable de Usuario
/// </summary>
public static async Task <Usuario> GetUser()
{
var path = "/v1/usuario";
for (var i = 1; i <= TotalTryes; i++)
{
using (var response = await ApiClient.GetApiClient().GetAsync(path))
{
if (response.IsSuccessStatusCode)
{
var usuario = await response.Content.ReadAsAsync <Usuario>();
return(usuario);
}
if (response.StatusCode == HttpStatusCode.Unauthorized)
{
await ApiServiceLogin.GetServiceLogin().ReLogin();
}
else
{
ErrorGeneral error;
error = await response.Content.ReadAsAsync <ErrorGeneral>();
throw new Exception(error.mensaje);
}
}
}
throw new Exception("AuntenticacionFallida");
}
/// <summary>
/// Registra una cancion personal en el servidor
/// </summary>
/// <param name="cancionPersonal">La cancion personal a registrar</param>
/// <returns>La cancion personal registrada</returns>
/// <exception cref="Exception">Alguna excepcion que pueda ocurrir al guardar la cancion</exception>
public static async Task <CancionPersonal> RegisterSong(CancionPersonal cancionPersonal)
{
var path = "/v1/biblioteca-personal/canciones";
for (var i = 1; i <= CantidadIntentos; i++)
{
using (var response = await ApiClient.GetApiClient().PostAsJsonAsync(path, cancionPersonal))
{
if (response.StatusCode == HttpStatusCode.Created)
{
var cancionRegistered = await response.Content.ReadAsAsync <CancionPersonal>();
return(cancionRegistered);
}
if (response.StatusCode == HttpStatusCode.Unauthorized)
{
await ApiServiceLogin.GetServiceLogin().ReLogin();
}
else
{
ErrorGeneral error;
error = await response.Content.ReadAsAsync <ErrorGeneral>();
throw new Exception(error.mensaje);
}
}
}
throw new Exception("AuntenticacionFallida");
}
/// <summary>
/// Inicia sesion con las credenciales indicadas
/// </summary>
/// <param name="login">El objeto que contiene las credenciales del usuario</param>
/// <param name="desdeLocal">
/// Inidica si se iniciara sesion con las credenciales proporcionadas por el usuario
/// o con credenciales almacenadas
/// </param>
/// <returns>Task</returns>
private async Task InciarSesion(Login login, bool desdeLocal)
{
try
{
await ApiServiceLogin.GetServiceLogin().Login(login);
var usuario = await UsuarioClient.GetUser();
usuario.login = login;
ManejadorDeUsuariosLogeados.GetManejadorDeUsuariosLogeados().InicioSesionUsuario(usuario);
NavigationService?.Navigate(new Canciones());
}
catch (HttpRequestException)
{
if (!desdeLocal)
{
new MensajeEmergente().MostrarMensajeError("No se puede conectar al servidor");
}
else
{
NavigationService?.Navigate(new Canciones());
}
}
catch (Exception exception)
{
if (exception.Message == "AuntenticacionFallida")
{
new MensajeEmergente().MostrarMensajeError("No se pudo iniciar sesión, intentelo nuevamente");
}
new MensajeEmergente().MostrarMensajeAdvertencia(exception.Message);
}
}
/// <summary>
/// Recupera las canciones que existen en la biblioteca personal del usuario actual
/// </summary>
/// <returns>Una lista de canciones personales</returns>
/// <exception cref="Exception">Alguna excepcion que pueda ocurrir al recuperar las canciones</exception>
public static async Task <List <CancionPersonal> > GetCancionesPersonales()
{
var path = "/v1/biblioteca-personal/canciones?cantidad=250&pagina=1";
for (var i = 1; i <= CantidadIntentos; i++)
{
using (var response = await ApiClient.GetApiClient().GetAsync(path))
{
if (response.IsSuccessStatusCode)
{
var canciones = await response.Content.ReadAsAsync <List <CancionPersonal> >();
return(canciones);
}
if (response.StatusCode == HttpStatusCode.Unauthorized)
{
await ApiServiceLogin.GetServiceLogin().ReLogin();
}
else
{
ErrorGeneral error;
error = await response.Content.ReadAsAsync <ErrorGeneral>();
throw new Exception(error.mensaje);
}
}
}
throw new Exception("AuntenticacionFallida");
}
/// <summary>
/// Método que solicita al servidor eliminar una lista de reproducción
/// </summary>
/// <param name="idListaReproduccion">El identificador de la lista de reproducción a eliminar</param>
/// <returns></returns>
public static async Task <ListaReproduccion> DeteleListaReproduccion(int idListaReproduccion)
{
var path = $"/v1/listas-de-reproduccion/{idListaReproduccion}";
for (var i = 1; i <= CantidadIntentos; i++)
{
using (var response = await ApiClient.GetApiClient().DeleteAsync(path))
{
if (response.StatusCode == HttpStatusCode.Accepted)
{
var listaReproduccionDeleted = await response.Content.ReadAsAsync <ListaReproduccion>();
return(listaReproduccionDeleted);
}
if (response.StatusCode == HttpStatusCode.Unauthorized)
{
await ApiServiceLogin.GetServiceLogin().ReLogin();
}
else if (response.StatusCode == HttpStatusCode.NotFound)
{
throw new Exception("No existe la lista de reproducción que se desea eliminar");
}
else
{
ErrorGeneral error;
error = await response.Content.ReadAsAsync <ErrorGeneral>();
throw new Exception(error.mensaje);
}
}
}
throw new Exception("AuntenticacionFallida");
}
/// <summary>
/// Solicita al servidor eliminar una cancion
/// </summary>
/// <param name="idCancion">El id de la cancion a eliminar</param>
/// <returns>La cancion eliminada</returns>
/// <exception cref="Exception">Una excepcion que pueda ocurrir</exception>
public static async Task <CancionPersonal> DeteleCancion(int idCancion)
{
var path = $"/v1/biblioteca-personal/canciones/{idCancion}";
for (var i = 1; i <= CantidadIntentos; i++)
{
using (var response = await ApiClient.GetApiClient().DeleteAsync(path))
{
if (response.StatusCode == HttpStatusCode.Accepted)
{
var cancionDeleted = await response.Content.ReadAsAsync <CancionPersonal>();
return(cancionDeleted);
}
if (response.StatusCode == HttpStatusCode.Unauthorized)
{
await ApiServiceLogin.GetServiceLogin().ReLogin();
}
else if (response.StatusCode == HttpStatusCode.NotFound)
{
throw new Exception("No existe la cancion que se desea eliminar");
}
else
{
ErrorGeneral error;
error = await response.Content.ReadAsAsync <ErrorGeneral>();
throw new Exception(error.mensaje);
}
}
}
throw new Exception("AuntenticacionFallida");
}
/// <summary>
/// Recupera los generos que pertenecen a una cancion
/// </summary>
/// <param name="idCancion">El id de la cancion a recuperar sus generos</param>
/// <param name="idAlbum">El id del album al que pertenece la cancion</param>
/// <returns>Una lista de Generos</returns>
/// <exception cref="Exception">Alguna excepción que pueda ocurrir</exception>
public static async Task <List <Genero> > GetGenerosFromCancion(int idCancion, int idAlbum)
{
var path = $"/v1/creador-de-contenido/albumes/{idAlbum}/canciones/{idCancion}/generos";
for (var i = 1; i <= CantidadIntentos; i++)
{
using (var response = await ApiClient.GetApiClient().GetAsync(path))
{
if (response.IsSuccessStatusCode)
{
var generosFromSong = await response.Content.ReadAsAsync <List <Genero> >();
return(generosFromSong);
}
if (response.StatusCode == HttpStatusCode.Unauthorized)
{
await ApiServiceLogin.GetServiceLogin().ReLogin();
}
else if (response.StatusCode == HttpStatusCode.NotFound)
{
throw new Exception("No existe la cancion indicada");
}
else
{
ErrorGeneral error;
error = await response.Content.ReadAsAsync <ErrorGeneral>();
throw new Exception(error.mensaje);
}
}
}
throw new Exception("AuntenticacionFallida");
}
/// <summary>
/// Obtiene el radio de una cancion
/// </summary>
/// <param name="idCancion">El id de la cancion de la cual se quiere obtener la radio</param>
/// <returns>Una lista de canciones</returns>
/// <exception cref="Exception">Una excepcion que indica que algo salio mal en selrvidor</exception>
public static async Task <List <Cancion> > GetRadioFromSong(int idCancion)
{
var path = $"/v1/estacion-de-radio/{idCancion}";
for (var i = 1; i <= CantidadIntentos; i++)
{
using (var response = await ApiClient.GetApiClient().GetAsync(path))
{
if (response.IsSuccessStatusCode)
{
var songsOfRadio = await response.Content.ReadAsAsync <List <Cancion> >();
return(songsOfRadio);
}
if (response.StatusCode == HttpStatusCode.Unauthorized)
{
await ApiServiceLogin.GetServiceLogin().ReLogin();
}
else if (response.StatusCode == HttpStatusCode.NotFound)
{
throw new Exception("No existe la cancion indicada");
}
else
{
ErrorGeneral error;
error = await response.Content.ReadAsAsync <ErrorGeneral>();
throw new Exception(error.mensaje);
}
}
}
throw new Exception("AuntenticacionFallida");
}
/// <summary>
/// Recupera el historial del usuario actual
/// </summary>
/// <param name="cantidadDeDias">
/// La cantidad de dias a partir de la fecha actual de los cuales se obtendra
/// el historial
/// </param>
/// <param name="cantidadDeResultados">La cantidad de resultados a obtener</param>
/// <returns>Una Lista de Canciones</returns>
/// <exception cref="Exception">Alguna excepcion que pueda ocurrir al recuperar el creador de conenidp</exception>
public static async Task<List<Cancion>> GetHistorial(int cantidadDeDias, int cantidadDeResultados)
{
var path = $"/v1/historial-reproduccion/canciones?cantidad={cantidadDeResultados}&pagina=1&" +
$"ultimos_dias_a_obtener={cantidadDeDias}";
for (var i = 1; i <= CantidadIntentos; i++)
using (var response = await ApiClient.GetApiClient().GetAsync(path))
{
if (response.IsSuccessStatusCode)
{
var canciones = await response.Content.ReadAsAsync<List<Cancion>>();
return canciones;
}
if (response.StatusCode == HttpStatusCode.Unauthorized)
{
await ApiServiceLogin.GetServiceLogin().ReLogin();
}
else
{
throw new Exception("Ocurrio un error en el servidor y no se pude recuperar" +
" el historial");
}
}
throw new Exception("AuntenticacionFallida");
}
/// <summary>
/// Recupera el creador de contenido del usuario logeado
/// </summary>
/// <returns>El creador de contenido del usuario logeado</returns>
/// <exception cref="Exception">Alguna excepcion que ocurrio en la solicitud</exception>
public static async Task <CreadorContenido> GetCreadorContenidoFromActualUser()
{
var path = "/v1/creador-de-contenido";
for (var i = 1; i <= CantidadIntentos; i++)
{
using (var response = await ApiClient.GetApiClient().GetAsync(path))
{
if (response.IsSuccessStatusCode)
{
var creadores = await response.Content.ReadAsAsync <CreadorContenido>();
return(creadores);
}
if (response.StatusCode == HttpStatusCode.NotFound)
{
throw new Exception("SinCreadorDeContenido");
}
if (response.StatusCode == HttpStatusCode.Unauthorized)
{
await ApiServiceLogin.GetServiceLogin().ReLogin();
}
else
{
ErrorGeneral error;
error = await response.Content.ReadAsAsync <ErrorGeneral>();
throw new Exception(error.mensaje);
}
}
}
throw new Exception("AuntenticacionFallida");
}
/// <summary>
/// Recupera la calificacion de una cancion
/// </summary>
/// <param name="idCancion">El id de la cancion a recuperar su calificacion</param>
/// <returns>La calificacion de la cancion</returns>
/// <exception cref="Exception">Alguna excepcion que puede ocurrir</exception>
public static async Task <Calificacion> GetCalificacion(int idCancion)
{
var path = $"/v1/canciones/{idCancion}/calificaciones";
for (var i = 1; i <= CantidadIntentos; i++)
{
using (var response = await ApiClient.GetApiClient().GetAsync(path))
{
if (response.StatusCode == HttpStatusCode.OK)
{
var calificacionAdded = await response.Content.ReadAsAsync <Calificacion>();
return(calificacionAdded);
}
if (response.StatusCode == HttpStatusCode.Unauthorized)
{
await ApiServiceLogin.GetServiceLogin().ReLogin();
}
else if (response.StatusCode == HttpStatusCode.NotFound)
{
throw new Exception("NoCalificada");
}
else
{
ErrorGeneral error;
error = await response.Content.ReadAsAsync <ErrorGeneral>();
throw new Exception(error.mensaje);
}
}
}
throw new Exception("AuntenticacionFallida");
}
/// <summary>
/// Recupera los albumes de un creador de contenido
/// </summary>
/// <param name="idContentCreator">El id del creador de contenido a obtener sus albumes</param>
/// <returns>Una Lista de Albumes</returns>
/// <exception cref="Exception">Alguna excepción que ocurra al obtener los albumes</exception>
public static async Task <List <Album> > GetAlbumsFromContentCreator(int idContentCreator)
{
var path = $"/v1/creadores-de-contenido/{idContentCreator.ToString()}/albumes";
for (var i = 1; i <= CantidadIntentos; i++)
{
using (var response = await ApiClient.GetApiClient().GetAsync(path))
{
if (response.IsSuccessStatusCode)
{
var albumes = await response.Content.ReadAsAsync <List <Album> >();
return(albumes);
}
if (response.StatusCode == HttpStatusCode.Unauthorized)
{
await ApiServiceLogin.GetServiceLogin().ReLogin();
}
else if (response.StatusCode == HttpStatusCode.NotFound)
{
throw new Exception("No existe el artista indicado");
}
else
{
ErrorGeneral error;
error = await response.Content.ReadAsAsync <ErrorGeneral>();
throw new Exception(error.mensaje);
}
}
}
throw new Exception("AuntenticacionFallida");
}
/// <summary>
/// Método del servidor que realiza la petición HTTP para registrar al CreadorContenido
/// </summary>
/// <param name="contentCreator">Variable de tipo de CreadorContenido que contiene su información</param>
/// <returns>Una variable de tipo CreadorContenido o una excepción si la respuesta de la solicitud es incorrecta</returns>
public static async Task <CreadorContenido> RegisterCreadorContenido(CreadorContenido contentCreator)
{
CreadorContenido contentCreatorRegister;
var path = "/v1/creador-de-contenido";
for (var i = 1; i <= CantidadIntentos; i++)
{
using (var response = await ApiClient.GetApiClient().PostAsJsonAsync(path, contentCreator))
{
if (response.IsSuccessStatusCode)
{
contentCreatorRegister = await response.Content.ReadAsAsync <CreadorContenido>();
var pathRegisteredGenero = "/v1/creador-de-contenido/generos";
foreach (var genero in contentCreator.generos)
{
using (var responseAddGenero =
await ApiClient.GetApiClient().PostAsJsonAsync(pathRegisteredGenero, genero))
{
if (!responseAddGenero.IsSuccessStatusCode)
{
throw new Exception("No se pudieron guardar todos los generos, " +
"puede modificarlos mas adelante");
}
}
}
return(contentCreatorRegister);
}
if (response.StatusCode == HttpStatusCode.BadRequest)
{
List <ErrorGeneral> errores;
errores = await response.Content.ReadAsAsync <List <ErrorGeneral> >();
var error = ProcessBadRequesCode(errores[0].error);
throw new Exception(error);
}
if (response.StatusCode == HttpStatusCode.Unauthorized)
{
await ApiServiceLogin.GetServiceLogin().ReLogin();
}
else
{
ErrorGeneral error;
error = await response.Content.ReadAsAsync <ErrorGeneral>();
throw new Exception(error.mensaje);
}
}
}
throw new Exception("AuntenticacionFallida");
}
/// <summary>
/// Regresa la instancia del HttpClient
/// </summary>
/// <returns>El HttpClient</returns>
public static HttpClient GetApiClient()
{
if (_apiClient == null)
{
_apiClient = new ApiClient();
_httpClient = new HttpClient();
_httpClient.DefaultRequestHeaders.Accept.Clear();
_httpClient.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
_httpClient.BaseAddress = new Uri(Configuration.URIRestServer);
}
_httpClient.DefaultRequestHeaders.Clear();
_httpClient.DefaultRequestHeaders.Add("x-access-token", ApiServiceLogin.GetServiceLogin().GetAccessToken());
return(_httpClient);
}
private async Task <RespuestaSolicitudSubirArchivo> UploadCover(string path, int idCover,
AsyncClientStreamingCall <SolicitudSubirPortada, RespuestaSolicitudSubirArchivo> call)
{
var extension = Path.GetExtension(path).Replace(".", "");
var formatImage = ConvertExtensionToFormatoImagen(extension);
if (File.Exists(path))
{
var requestUploadCover = new SolicitudSubirPortada();
requestUploadCover.InformacionPortada = new InformacionPortada();
requestUploadCover.InformacionPortada.IdElementoDePortada = idCover;
requestUploadCover.InformacionPortada.FormatoImagen = formatImage;
requestUploadCover.TokenAutenticacion = ApiServiceLogin.GetServiceLogin().GetAccessToken();
var coverBytes = FileManager.ByteArrayFromImageFile(path);
using (call)
{
var totalChunks = coverBytes.Length / ChunkSize;
var finalBytes = coverBytes.Length % ChunkSize;
try
{
for (var i = 0; i < totalChunks; i++)
{
requestUploadCover.Data =
ByteString.CopyFrom(FileManager.SubArray(coverBytes, i * ChunkSize, ChunkSize));
await call.RequestStream.WriteAsync(requestUploadCover);
}
requestUploadCover.Data =
ByteString.CopyFrom(FileManager.SubArray(coverBytes, totalChunks, finalBytes));
await call.RequestStream.WriteAsync(requestUploadCover);
await call.RequestStream.CompleteAsync();
}
catch (RpcException ex)
{
if (ex.StatusCode != StatusCode.OK)
{
throw new RpcException(ex.Status, ex.Message);
}
}
return(await call.ResponseAsync);
}
}
throw new Exception("No se encontro el archivo en la ruta especifica");
}
/// <summary>
/// Edita una cancion en el servidor
/// </summary>
/// <param name="cancion">La cancion a editar</param>
/// <param name="idAlbum">El id del Album al que pertenece la cancion</param>
/// <param name="actualsGeneros">La lista de generos actuales de la cancion</param>
/// <param name="actualsCreadores">la lista de creadores actuales de la cancion</param>
/// <returns>La cancion registrada</returns>
/// <exception cref="Exception">Alguna excepcion que pueda ocurrir al guardar la cancion</exception>
public static async Task <Cancion> EditSong(Cancion cancion, int idAlbum, List <Genero> actualsGeneros,
List <CreadorContenido> actualsCreadores)
{
var path = $"/v1/creador-de-contenido/albumes/{idAlbum}/canciones/{cancion.id}";
for (var i = 1; i <= CantidadIntentos; i++)
{
using (var response = await ApiClient.GetApiClient().PutAsJsonAsync(path, cancion))
{
if (response.StatusCode == HttpStatusCode.Accepted)
{
var cancionEdited = await response.Content.ReadAsAsync <Cancion>();
await AddNewGeneroToSong(cancionEdited.id, idAlbum, cancion.generos, actualsGeneros);
await DeleteOldGeneroToSong(cancionEdited.id, idAlbum, cancion.generos, actualsGeneros);
await AddNewCreadoresToSong(cancionEdited.id, idAlbum, cancion.creadores_de_contenido,
actualsCreadores);
await DeleteOldCreadoresToSong(cancionEdited.id, idAlbum, cancion.creadores_de_contenido,
actualsCreadores);
return(cancionEdited);
}
if (response.StatusCode == HttpStatusCode.Unauthorized)
{
await ApiServiceLogin.GetServiceLogin().ReLogin();
}
else if (response.StatusCode == HttpStatusCode.NotFound)
{
throw new Exception("No existe la cancion que se desea editar");
}
else
{
ErrorGeneral error;
error = await response.Content.ReadAsAsync <ErrorGeneral>();
throw new Exception(error.mensaje);
}
}
}
throw new Exception("AuntenticacionFallida");
}
/// <summary>
/// Método que solicita al servidor agregar una canción a una lista de reproducción
/// </summary>
/// <param name="listaReproduccion">Instancia de ListaReproduccion</param>
/// <returns>La lista de reproducción creada</returns>
public static async Task <Cancion> RegisterCancionAListaReproduccion(int idListaReproduccion, int idCancion)
{
var cancion = new Cancion();
cancion.id = idCancion;
var path = $"/v1/listas-de-reproduccion/{idListaReproduccion}/canciones";
for (var i = 1; i <= CantidadIntentos; i++)
{
using (var response = await ApiClient.GetApiClient().PostAsJsonAsync(path, cancion))
{
if (response.IsSuccessStatusCode)
{
var cancionRegistered = await response.Content.ReadAsAsync <Cancion>();
return(cancionRegistered);
}
if (response.StatusCode == HttpStatusCode.BadRequest)
{
List <ErrorGeneral> errores;
errores = await response.Content.ReadAsAsync <List <ErrorGeneral> >();
throw new Exception(errores[0].mensaje);
}
if (response.StatusCode == HttpStatusCode.Unauthorized)
{
await ApiServiceLogin.GetServiceLogin().ReLogin();
}
else
{
ErrorGeneral error;
error = await response.Content.ReadAsAsync <ErrorGeneral>();
throw new Exception(error.mensaje);
}
}
}
throw new Exception("AuntenticacionFallida");
}
/// <summary>
/// Solicita al API registrar un album
/// </summary>
/// <param name="album"></param>
/// <returns>El Album registrado</returns>
/// <exception cref="Exception">Alguna excepcion que puede ocurrir al mandar la solicitud al servidor</exception>
public static async Task <Album> RegisterAlbum(Album album)
{
var path = "/v1/creador-de-contenido/albumes";
for (var i = 1; i <= CantidadIntentos; i++)
{
using (var response = await ApiClient.GetApiClient().PostAsJsonAsync(path, album))
{
if (response.IsSuccessStatusCode)
{
var albumRegistered = await response.Content.ReadAsAsync <Album>();
return(albumRegistered);
}
if (response.StatusCode == HttpStatusCode.BadRequest)
{
List <ErrorGeneral> errores;
errores = await response.Content.ReadAsAsync <List <ErrorGeneral> >();
throw new Exception(errores[0].mensaje);
}
if (response.StatusCode == HttpStatusCode.Unauthorized)
{
await ApiServiceLogin.GetServiceLogin().ReLogin();
}
else
{
ErrorGeneral error;
error = await response.Content.ReadAsAsync <ErrorGeneral>();
throw new Exception(error.mensaje);
}
}
}
throw new Exception("AuntenticacionFallida");
}
public async Task <MemoryStream> GetAlbumCover(int idAlbum, Calidad calidad)
{
var channel = new Channel(Configuration.URIGrpcServer, ChannelCredentials.Insecure);
var client = new Portadas.PortadasClient(channel);
var request =
CreateSolicitudObtenerPortada(idAlbum, ApiServiceLogin.GetServiceLogin().GetAccessToken(), calidad);
var call = client.ObtenerPortadaAlbum(request);
MemoryStream cover = null;
for (var i = 1; i <= TryNumbres; i++)
{
try
{
cover = await GetCover(call);
break;
}
catch (RpcException ex)
{
throw new RpcException(ex.Status, ex.Message);
}
}
/// <summary>
/// Califica una cancion
/// </summary>
/// <param name="idCancion">El id de la cancion a calificar</param>
/// <param name="calificacionEstrellas">La calificacion</param>
/// <returns>La calificacion agregada</returns>
/// <exception cref="Exception">Alguna excepcion que puede ocurrir</exception>
public static async Task <Calificacion> AddCalificacion(int idCancion, int calificacionEstrellas)
{
var path = $"/v1/canciones/{idCancion}/calificaciones";
var calificacion = new Calificacion
{
calificacion_estrellas = calificacionEstrellas
};
for (var i = 1; i <= CantidadIntentos; i++)
{
using (var response = await ApiClient.GetApiClient().PostAsJsonAsync(path, calificacion))
{
if (response.StatusCode == HttpStatusCode.Created)
{
var calificacionAdded = await response.Content.ReadAsAsync <Calificacion>();
return(calificacionAdded);
}
if (response.StatusCode == HttpStatusCode.Unauthorized)
{
await ApiServiceLogin.GetServiceLogin().ReLogin();
}
else if (response.StatusCode == HttpStatusCode.NotFound)
{
throw new Exception("No existe la cancion que desea calificar");
}
else
{
ErrorGeneral error;
error = await response.Content.ReadAsAsync <ErrorGeneral>();
throw new Exception(error.mensaje);
}
}
}
throw new Exception("AuntenticacionFallida");
}
/// <summary>
/// Solicita al servidor subir una cancion
/// </summary>
/// <param name="path">La ruta de la cancion</param>
/// <param name="idSong">El id de la cancion a subir</param>
/// <param name="isPersonal">Indica si la cancion personal</param>
/// <returns>Task</returns>
public async Task UploadSong(string path, int idSong, bool isPersonal)
{
var channel = new Channel(Configuration.URIGrpcServer, ChannelCredentials.Insecure);
var client = new Canciones.CancionesClient(channel);
var extension = Path.GetExtension(path).Replace(".", "");
var formatAudio = ConvertExtensionToFormatAudio(extension);
if (File.Exists(path))
{
for (var o = 1; o <= CounTrys; o++)
{
var resquestUploadSong = new SolicitudSubirCancion();
resquestUploadSong.InformacionCancion = new InformacionCancion();
resquestUploadSong.InformacionCancion.IdCancion = idSong;
resquestUploadSong.InformacionCancion.FormatoCancion = formatAudio;
resquestUploadSong.TokenAutenticacion = ApiServiceLogin.GetServiceLogin().GetAccessToken();
var songBytes = File.ReadAllBytes(path);
AsyncClientStreamingCall <SolicitudSubirCancion, RespuestaSolicitudSubirArchivo> call;
call = isPersonal ? client.SubirCancionPersonal() : client.SubirCancion();
using (call)
{
try
{
var totalChunks = songBytes.Length / ChunkSize;
var finalBytes = songBytes.Length % ChunkSize;
for (var i = 0; i < totalChunks; i++)
{
resquestUploadSong.Data =
ByteString.CopyFrom(FileManager.SubArray(songBytes, i * ChunkSize, ChunkSize));
await call.RequestStream.WriteAsync(resquestUploadSong);
OnPorcentageUp?.Invoke(CalculatePercentageUpload(i, totalChunks));
}
resquestUploadSong.Data =
ByteString.CopyFrom(FileManager.SubArray(songBytes, totalChunks, finalBytes));
await call.RequestStream.WriteAsync(resquestUploadSong);
await call.RequestStream.CompleteAsync();
}
catch (RpcException ex)
{
throw new RpcException(ex.Status);
}
var response = await call.ResponseAsync;
if (response.Error == Error.Ninguno)
{
OnUploadTerminated?.Invoke();
return;
}
if (response.Error == Error.TokenInvalido || response.Error == Error.TokenFaltante)
{
await ApiServiceLogin.GetServiceLogin().ReLogin();
}
else
{
ManageErrorsUploadSong(response.Error);
}
}
}
throw new Exception("AuntenticacionFallida");
}
}
/// <summary>
/// Registra un nuevo usuario
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private async void OnClickRegistrarButton(object sender, RoutedEventArgs e)
{
if (ValidarTextBoxNombre() && ValidarTextBoxCorreo() && ValidarTextBoxNombreUsuario() &&
ValidarTextBoxContraseña())
{
cancelarButton.IsEnabled = false;
registrarUsuarioButton.IsEnabled = false;
var usuario = CrearUsuario();
var usuarioRegistrado = false;
try
{
await UsuarioClient.RegisterUsuario(usuario);
usuarioRegistrado = true;
var usuarioLogin = new Login
{
Password = usuario.contrasena,
User = usuario.nombre_usuario
};
await ApiServiceLogin.GetServiceLogin().Login(usuarioLogin);
var usuarioLogeado = await UsuarioClient.GetUser();
usuarioLogeado.login = usuarioLogin;
ManejadorDeUsuariosLogeados.GetManejadorDeUsuariosLogeados().InicioSesionUsuario(usuarioLogeado);
if (_rutaImagen != "")
{
var clientePortadas = new CoversClient();
clientePortadas.UploadUserCover(_rutaImagen);
}
}
catch (HttpRequestException)
{
new MensajeEmergente().MostrarMensajeError("No se puede conectar al servidor");
}
catch (RpcException)
{
new MensajeEmergente().MostrarMensajeError(
"No se pudo guardar la imagen de portada, puede subirla " +
"mas adelante");
}
catch (Exception exception)
{
new MensajeEmergente().MostrarMensajeAdvertencia(exception.Message);
}
if (usuarioRegistrado)
{
if (usuario.tipo_usuario == TipoUsuario.CreadorDeContenido)
{
NavigationService?.Navigate(new RegistrarCreadorContenido());
}
else
{
NavigationService?.Navigate(new Canciones());
}
}
cancelarButton.IsEnabled = true;
registrarUsuarioButton.IsEnabled = true;
}
}
/// <summary>
/// Realiza las peticiones al servidor para modificar la información de un creador de contenido
/// </summary>
/// <param name="contentCreator">Variable de tipo de CreadorContenido que contiene su información</param>
/// <param name="actuals">La lista de generos actualoizada del creador de contenido</param>
/// <returns>Una variable de tipo CreadorContenido o una excepción si la respuesta de la solicitud es incorrecta</returns>
public static async Task <CreadorContenido> EditCreadorContenido(CreadorContenido contentCreator,
List <Genero> actuals)
{
CreadorContenido contentCreatorRegister;
var path = "/v1/creador-de-contenido";
for (var i = 1; i <= CantidadIntentos; i++)
{
using (var response = await ApiClient.GetApiClient().PutAsJsonAsync(path, contentCreator))
{
if (response.IsSuccessStatusCode)
{
contentCreatorRegister = await response.Content.ReadAsAsync <CreadorContenido>();
var generosToDelete = CalculateGenerosToDelete(contentCreator.generos, actuals);
foreach (var genero in generosToDelete)
{
var pathToDeleteGenero = $"/v1/creador-de-contenido/generos/{genero.id}";
using (var responseAddGenero =
await ApiClient.GetApiClient().DeleteAsync(pathToDeleteGenero))
{
if (!responseAddGenero.IsSuccessStatusCode)
{
throw new Exception("No se pudieron modificar todos los generos");
}
}
}
var generosToAdd = CalculateGenerosToAdd(contentCreator.generos, actuals);
var pathToAddGenero = "/v1/creador-de-contenido/generos";
foreach (var genero in generosToAdd)
{
using (var responseAddGenero =
await ApiClient.GetApiClient().PostAsJsonAsync(pathToAddGenero, genero))
{
if (!responseAddGenero.IsSuccessStatusCode)
{
throw new Exception("No se pudieron modificar todos los generos");
}
}
}
return(contentCreatorRegister);
}
if (response.StatusCode == HttpStatusCode.BadRequest)
{
List <ErrorGeneral> errores;
errores = await response.Content.ReadAsAsync <List <ErrorGeneral> >();
var error = ProcessBadRequesCode(errores[0].error);
throw new Exception(error);
}
if (response.StatusCode == HttpStatusCode.Unauthorized)
{
await ApiServiceLogin.GetServiceLogin().ReLogin();
}
else
{
ErrorGeneral error;
error = await response.Content.ReadAsAsync <ErrorGeneral>();
throw new Exception(error.mensaje);
}
}
}
throw new Exception("AuntenticacionFallida");
}
/// <summary>
/// Registra una cancion en el servidor
/// </summary>
/// <param name="idAlbum">El id del Album al que pertenece la cancion</param>
/// <param name="cancion">La cancion a registrar</param>
/// <returns>La cancion registrada</returns>
/// <exception cref="Exception">Alguna excepcion que pueda ocurrir al guardar la cancion</exception>
public static async Task <Cancion> RegisterSong(int idAlbum, Cancion cancion)
{
var path = $"/v1/creador-de-contenido/albumes/{idAlbum}/canciones";
for (var i = 1; i <= CantidadIntentos; i++)
{
using (var response = await ApiClient.GetApiClient().PostAsJsonAsync(path, cancion))
{
if (response.StatusCode == HttpStatusCode.Created)
{
var cancionRegistered = await response.Content.ReadAsAsync <Cancion>();
var pathAddGenero =
$"/v1/creador-de-contenido/albumes/{idAlbum}/canciones/{cancionRegistered.id}/generos";
foreach (var genero in cancion.generos)
{
using (var responseAddGenero =
await ApiClient.GetApiClient().PostAsJsonAsync(pathAddGenero, genero))
{
if (responseAddGenero.StatusCode != HttpStatusCode.Created)
{
throw new Exception("No se pudieron guardar todos los generos, " +
"puede modificarlos mas adelante");
}
}
}
var pathAddContentCreator = $"/v1/creador-de-contenido/albumes/{idAlbum}/canciones/" +
$"{cancionRegistered.id}/creadores-de-contenido";
foreach (var contentCreator in cancion.creadores_de_contenido)
{
using (var responseAddGenero = await ApiClient.GetApiClient()
.PostAsJsonAsync(pathAddContentCreator, contentCreator))
{
if (responseAddGenero.StatusCode != HttpStatusCode.Created)
{
throw new Exception("No se pudieron guardar todos los artistas, " +
"puede modificarlos mas adelante");
}
}
}
return(cancionRegistered);
}
if (response.StatusCode == HttpStatusCode.Unauthorized)
{
await ApiServiceLogin.GetServiceLogin().ReLogin();
}
else if (response.StatusCode == HttpStatusCode.NotFound)
{
throw new Exception("No existe el album a donde desea agregar la cancion");
}
else
{
ErrorGeneral error;
error = await response.Content.ReadAsAsync <ErrorGeneral>();
throw new Exception(error.mensaje);
}
}
}
throw new Exception("AuntenticacionFallida");
}
/// <summary>
/// Solicita al servidor la cancion con el id cancion en la calidad indicada
/// </summary>
/// <param name="idGetSong">El id de la cancion a solicitar al servidor</param>
/// <param name="calidad">La calidad de la cancion a solicitar</param>
/// <param name="isPersonalGetSong">Indica si la cancion es personal o normal</param>
public async void GetSong(int idGetSong, Calidad calidad, bool isPersonalGetSong)
{
_getSong = true;
var channel = new Channel(Configuration.URIGrpcServer, ChannelCredentials.Insecure);
var client = new Canciones.CancionesClient(channel);
var request = new SolicitudObtenerCancion();
var memoryStream = new MemoryStream();
var position = 0;
FormatoAudio formatAudio;
var error = Error.Ninguno;
for (var i = 1; i <= CounTrys; i++)
{
try
{
request.IdCancion = idGetSong;
request.CalidadCancionARecuperar = calidad;
request.TokenAutenticacion = ApiServiceLogin.GetServiceLogin().GetAccessToken();
var call = isPersonalGetSong
? client.ObtenerCancionPersonal(request)
: client.ObtenerCancion(request);
using (call)
{
while (await call.ResponseStream.MoveNext() && _getSong)
{
var response = call.ResponseStream.Current;
memoryStream.Write(response.Data.ToByteArray(), 0, response.Data.Length);
position += response.Data.Length;
formatAudio = response.FormatoCancion;
error = response.Error;
if (position == ChunkSize)
{
OnInitialRecivedSong?.Invoke(response.Data.ToByteArray(),
ConvertFormatAudioToExtension(formatAudio));
}
else if (position > ChunkSize)
{
OnSongChunkRived?.Invoke(response.Data.ToByteArray());
}
if (!_getSong)
{
memoryStream.Dispose();
}
}
}
}
catch (RpcException)
{
OnErrorRaised?.Invoke("No se pudo recuperar la canción, porfavor verifique su conexion a internet");
break;
}
if (error != Error.Ninguno)
{
if (error == Error.TokenFaltante || error == Error.TokenInvalido)
{
await ApiServiceLogin.GetServiceLogin().ReLogin();
}
else
{
OnErrorRaised?.Invoke(ManageGetSongError(error));
break;
}
}
else
{
OnTerminatedRecivedSong?.Invoke();
memoryStream.Dispose();
break;
}
}
if (error == Error.TokenFaltante || error == Error.TokenInvalido)
{
OnErrorRaised?.Invoke("AuntenticacionFallida");
}
}
