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"); } }