//listo
        public void createDataSongVersionLocal(DataSong pDataSongVersion)
        {
            TagManager.setID3(pDataSongVersion);

            int lversion_id = DatabaseManager.createVersion(pDataSongVersion);

            DatabaseManager.setVersion2Song(pDataSongVersion._LocalSongID, lversion_id.ToString());
        }
 public window_id3Tool(DataSong pMetadata)
 {
     this._SongToEdit = pMetadata;
     this._InfoManager = new InfoProvider();
     InitializeComponent();
     textbox_artist.Text = pMetadata._ID3Artist;
     textbox_genre.Text = pMetadata._ID3Genre;
     textbox_lyric.Text = pMetadata._ID3Lyrics;
     textbox_title.Text = pMetadata._ID3Title;
     textbox_album.Text = pMetadata._ID3Album;
     //this._MetadataVersion = this._InfoManager.getVersiono();
 }
 public static void setID3(DataSong pMetadata)
 {
     var taglibFile = TagLib.File.Create(pMetadata._SongDirectory);
     taglibFile.Tag.Title = pMetadata._ID3Title;
     string[] artists = {pMetadata._ID3Artist};
     taglibFile.Tag.Performers = artists;
     string[] genres = { pMetadata._ID3Genre };
     taglibFile.Tag.Genres = genres;
     taglibFile.Tag.Album = pMetadata._ID3Album;
     taglibFile.Tag.Comment = pMetadata._ID3Comment;
     taglibFile.Tag.Lyrics = pMetadata._ID3Lyrics;
     uint pYearParse = 0;
     uint.TryParse(pMetadata._ID3Year, out pYearParse);
     taglibFile.Tag.Year = pYearParse;
     taglibFile.Save();
 }
 //listo
 public async void createSong(DataSong pDataSongInitial)
 {
     RestTools rtop = new RestTools();
     Song songop = await rtop.createSong(pDataSongInitial._SongDirectory);
     if (songop == null)
     {
         Console.WriteLine("Canción No Fue Creada");
     }
     else
     {
         pDataSongInitial._SongID = songop.song_id.ToString();
         Song songtop = await rtop.createVersion(pDataSongInitial);
         if (songtop == null)
         {
         }
         else
         {
             Console.WriteLine("Primera NO FUE Versión Creada");
         }
     }
 }
 public static DataSong getID3ByDirectory(string pDirectory)
 {
     DataSong id3op = new DataSong();
     TagLib.File tagFile = TagLib.File.Create(pDirectory);
     List<string> p = new List<string>();
     id3op._SongDirectory = pDirectory;
     id3op._ID3Title = tagFile.Tag.Title;
     id3op._ID3Album = tagFile.Tag.Album;
     id3op._ID3Year = (tagFile.Tag.Year.ToString());
     id3op._ID3Lyrics = tagFile.Tag.Lyrics;
     if (tagFile.Tag.Genres.Length > 0)
     {
         id3op._ID3Genre = tagFile.Tag.Genres[0];
     }
     if (tagFile.Tag.Performers.Length > 0)
     {
         id3op._ID3Artist = tagFile.Tag.Performers[0];
     }
     id3op._SongName = tagFile.Name.Substring(tagFile.Name.LastIndexOf('\\') + 1);
     id3op.fillEmpty();
     return id3op;
 }
        /// <summary>
        /// Obtiene todas las canciones de un usario y su metadata
        /// </summary>
        /// <param name="user_name">
        /// nombre del usuario
        /// </param>
        /// <returns>
        /// Lista de objetos metadata 
        /// </returns>
        public async Task<List<DataSong>> getMetadataSongByUser(string user_name)
        {
            List<DataSong> songs_metadata = new List<DataSong>();

            using (HttpClient client = new HttpClient())
            {
                client.BaseAddress = new Uri(server_url);
                client.DefaultRequestHeaders.Accept.Clear();
                client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue(format));

                HttpResponseMessage response = await client.GetAsync(songs_by_user_path + "/" + user_name);

                if (response.IsSuccessStatusCode)
                {
                    MetadataAndSong[] sngs_n_met = await response.Content.ReadAsAsync<MetadataAndSong[]>();

                    for (int i = 0; i < sngs_n_met.Length; i++)
                    {
                        DataSong song_met = new DataSong();

                        song_met._ID3Artist = (sngs_n_met[i].id3v2_author);

                        song_met._ID3Title = (sngs_n_met[i].id3v2_title);
                        song_met._ID3Album = (sngs_n_met[i].id3v2_album);
                        song_met._ID3Year = (sngs_n_met[i].id3v2_year.ToString());
                        song_met._ID3Genre = (sngs_n_met[i].id3v2_genre);
                        song_met._ID3Lyrics = (sngs_n_met[i].id3v2_lyrics);
                        song_met._SongID = (sngs_n_met[i].song_id.ToString());
                        song_met._ID3Title = (sngs_n_met[i].id3v2_title);
                        song_met._SongDirectory = (sngs_n_met[i].song_directory);
                        song_met._SubmissionDate = (sngs_n_met[i].submission_date);
                        song_met._SongName = (sngs_n_met[i].song_name);
                        songs_metadata.Add(song_met);
                    }
                }
            }
            return songs_metadata;

        }
        /// <summary>
        /// Obtiene todas las canciones de un usuario
        /// </summary>
        /// <param name="user_name">
        /// 
        /// </param>
        /// <returns>
        /// 
        /// </returns>
        public static List<DataSong> getSongsOfUser(string user_name)
        {
            try
            {
                List<DataSong> songs_list = new List<DataSong>();

                using (SqlConnection connection = new SqlConnection(databaseConn))
                {
                    SqlCommand versionSongs = new SqlCommand();

                    versionSongs.CommandType = System.Data.CommandType.Text;

                    versionSongs.CommandText = "SELECT * "
                        + "FROM canc_metadata_tbl "
                        + "WHERE usr_name = @usrname";

                    versionSongs.Parameters.AddWithValue("@usrname", user_name);

                    versionSongs.Connection = connection;

                    connection.Open();

                    SqlDataReader reader = versionSongs.ExecuteReader();

                    if (reader.HasRows)
                    {
                        while (reader.Read())
                        {
                            DataSong dataSong = new DataSong();

                            dataSong._ID3Title = reader.GetString(1);
                            dataSong._ID3Artist = reader.GetString(2);
                            dataSong._ID3Album = reader.GetString(3);
                            dataSong._ID3Year = reader.GetInt32(4).ToString();
                            dataSong._ID3Genre = reader.GetString(5);
                            dataSong._ID3Lyrics = reader.GetString(6);
                            dataSong._SubmissionDate = reader.GetDateTime(7).ToString();
                            dataSong._SongDirectory = reader.GetString(8);
                            dataSong._LocalSongID = reader.GetInt32(9).ToString();
                            dataSong._SongID = reader.GetInt32(10).ToString();

                            songs_list.Add(dataSong);
                        }
                    }

                    reader.Close();
                    connection.Close();

                    return songs_list;
                }
            }
            catch (Exception e)
            {
                Console.WriteLine(e);

                return null;
            }
        }
        /// <summary>
        /// Cambia la version de metadata de una canción ya 
        /// existente
        /// </summary>
        /// <param name="dataSong">
        /// Objeto DataSong que contiene el id de la canción y 
        /// la información de la nueva versión
        /// </param>
        /// <returns>
        /// bool que es true si se hace el cambio exitosamente, false 
        /// en cualquier otro caso. 
        /// </returns>
        public static bool setVersion2Song(DataSong dataSong)
        {
            try
            {
                //crea la version a agregar a la canción
                int version_id = createVersion(dataSong);

                return setVersion2Song(dataSong._LocalSongID, version_id.ToString());
            }
            catch (Exception e)
            {
                Console.WriteLine(e);
                return false;
            }
        }
        /// <summary>
        /// Crea la versión de una canción.
        /// </summary>
        /// <param name="datasong">
        /// Objeto con todos los datos de la canción.
        /// </param>
        /// <returns>
        /// int que es el id de la versión, si es -2 no insertó nada
        /// y si es -1 hay un error.
        /// </returns>
        public static int createVersion(DataSong datasong)
        {
            try
            {
                int result = -2;
                using (SqlConnection connection = new SqlConnection(databaseConn))
                {
                    SqlCommand insertConnection = new SqlCommand();

                    insertConnection.CommandType = System.Data.CommandType.Text;
                    insertConnection.CommandText = "INSERT INTO versiones_tbl "+
                        "(local_song_id, id3v2_title, id3v2_author, id3v2_lyrics, id3v2_album, id3v2_genre, id3v2_year) "+
                        "output INSERTED.local_version_id VALUES (@lsng_id, @title, @author, @lyrics, @album, @genre, @year)";

                    insertConnection.Parameters.AddWithValue("@lsng_id", Convert.ToInt32(datasong._LocalSongID));
                    insertConnection.Parameters.AddWithValue("@title", datasong._ID3Title);
                    insertConnection.Parameters.AddWithValue("@author", datasong._ID3Artist);
                    insertConnection.Parameters.AddWithValue("@lyrics", datasong._ID3Lyrics);
                    insertConnection.Parameters.AddWithValue("@album", datasong._ID3Album);
                    insertConnection.Parameters.AddWithValue("@genre", datasong._ID3Genre);
                    insertConnection.Parameters.AddWithValue("@year", Convert.ToInt32(datasong._ID3Year));

                    insertConnection.Connection = connection;

                    connection.Open();

                    object obj = insertConnection.ExecuteScalar();
                    result = (int)obj;

                    connection.Close();

                }

                return result;
            }
            catch(Exception e)
            {
                etrace1 = datasong._ID3Lyrics + " "+datasong._ID3Title;
                Console.WriteLine(e);

                return -1;
            }
        }
        /// <summary>
        /// 
        /// </summary>
        /// <param name="userName"></param>
        /// <returns></returns>
        public static List<DataSong> getDesynchronizeSongsByUser(string userName)
        {
            List<DataSong> songs_list = new List<DataSong>();

            try
            {
                using (SqlConnection connection = new SqlConnection(databaseConn))
                {
                    SqlCommand versionSongs = new SqlCommand();

                    versionSongs.CommandType = System.Data.CommandType.Text;

                    versionSongs.CommandText = "SELECT id3v2_title, id3v2_author, id3v2_album, id3v2_year, id3v2_genre, id3v2_lyrics, "
                        + "submission_date, song_directory, local_song_id, cloud_song_id "
                        + "FROM canc_metadata_tbl "
                        + "WHERE usr_name = @usrname AND cloud_song_id = -1";

                    versionSongs.Parameters.AddWithValue("@usrname", userName);

                    versionSongs.Connection = connection;

                    connection.Open();

                    SqlDataReader reader = versionSongs.ExecuteReader();

                    if (reader.HasRows)
                    {
                        while (reader.Read())
                        {
                            DataSong dataSong = new DataSong();

                            dataSong._ID3Title = reader.GetString(0);
                            dataSong._ID3Artist = reader.GetString(1);
                            dataSong._ID3Album = reader.GetString(2);
                            dataSong._ID3Year = reader.GetInt32(3).ToString();
                            dataSong._ID3Genre = reader.GetString(4);
                            dataSong._ID3Lyrics = reader.GetString(5);
                            dataSong._SubmissionDate = reader.GetDateTime(6).ToString();
                            dataSong._SongDirectory = reader.GetString(7);
                            dataSong._LocalSongID = reader.GetInt32(8).ToString();
                            dataSong._SongID = reader.GetInt32(9).ToString();

                            songs_list.Add(dataSong);
                        }
                    }

                    reader.Close();
                    connection.Close();
                }
            }
            catch(Exception e)
            {
                Console.WriteLine(e.Message);

                DataSong dataSong = new DataSong();

                dataSong._ID3Title = e.Message + e.StackTrace;

                songs_list.Add(dataSong);
            }

            return songs_list;
        }
        /// <summary>
        /// Agrega una canción a un usurio
        /// </summary>
        /// <param name="usr_name">
        /// Usuario al que se le agrega la canción
        /// </param>
        /// <param name="song_name">
        /// Nombre del archivo de la canción
        /// </param>
        /// <param name="datasong">
        /// Objeto con toda la información de la canción
        /// </param>
        /// <returns>
        /// bool que es true si se pudo agregar la canción. 
        /// En cualquier otro caso es false
        /// </returns>
        public static bool addSong2User(string usr_name, DataSong datasong)
        {
            int local_song_id = createSong(datasong);
            datasong._LocalSongID = local_song_id.ToString();

            int version_id = createVersion(datasong);
            setVersion2Song(local_song_id.ToString(), version_id.ToString());

            return createProperty(usr_name, local_song_id.ToString(), datasong._SongName);
        }
        /// <summary>
        /// Crea una nueva canción en la base de datos local
        /// </summary>
        /// <param name="datasong">
        /// objeto con toda la información de la canción.
        /// </param>
        /// <returns>
        /// int que es el id de la canción agregada
        /// </returns>
        public static int createSong(DataSong datasong)
        {
            try
            {
                int result = -1;

                using (SqlConnection connection = new SqlConnection(databaseConn))
                {
                    SqlCommand insertSong = new SqlCommand();

                    insertSong.CommandType = System.Data.CommandType.Text;
                    insertSong.CommandText = "INSERT canciones_tbl (song_directory) output INSERTED.local_song_id VALUES (@directory)";

                    insertSong.Parameters.AddWithValue("@directory", datasong._SongDirectory);

                    insertSong.Connection = connection;

                    connection.Open();

                    object obj = insertSong.ExecuteScalar();
                    result = (int)obj;

                    connection.Close();
                }
                return result;
            }
            catch(Exception e)
            {
                Console.WriteLine(e);

                return -1;
            }
        }
 /// <summary>
 /// Agrega una version nueva a una canción ya creada.
 /// </summary>
 /// <param name="dataSong">
 /// Objeto DataSong que cnotiene la información 
 /// de la version
 /// </param>
 public void setVersion2Song(DataSong dataSong)
 {
     DatabaseManager.setVersion2Song(dataSong);
 }
 public void createLocalVersion(DataSong pDataSong)
 {
     int versionID = DatabaseManager.createVersion(pDataSong);
     DatabaseManager.setVersion2Song(pDataSong._LocalSongID, versionID.ToString());
 }
        /// <summary>
        /// 
        /// </summary>
        /// <param name="met"></param>
        /// <returns>
        /// 
        /// </returns>
        public async Task<Song> createVersion(DataSong met)
        {
            Song song;

            Version ver = new Version(met);
            ver.submission_date = "2015-11-15 07:23:23.440"; 
            using (var client = new HttpClient())
            {
                client.BaseAddress = new Uri(server_url);
                client.DefaultRequestHeaders.Accept.Clear();
                client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue(format));

                HttpResponseMessage response = await client.PostAsJsonAsync(versions_path, ver);

                if (response.IsSuccessStatusCode)
                {
                    ver = await response.Content.ReadAsAsync<Version>();

                    song = await getSongById(Convert.ToInt32(met._SongID));

                    song.metadata_id = ver.version_id;

                    HttpResponseMessage updsng = await client.PutAsJsonAsync<Song>(songs_path + "/" + song.song_id, song);

                    if (updsng.IsSuccessStatusCode)
                    {
                        Console.WriteLine("\nSe creo correctamente, metadata_id {0}", song.metadata_id);
                    }
                    else
                    {
                        song = null;
                        Console.WriteLine("\nError {0}", updsng.StatusCode);
                    }
                }
                else
                {
                    song = null;
                }

                return song;
            }
        }
        public Version(DataSong met)
        {
            song_id = Convert.ToInt32(met._SongID);

            id3v2_title = met._ID3Title;
            id3v2_author = met._ID3Artist;
            id3v2_album = met._ID3Album;
            id3v2_year = Convert.ToInt32(met._ID3Year);
            id3v2_genre = met._ID3Genre;
            id3v2_lyrics = met._ID3Lyrics;
            submission_date = met._SubmissionDate;
        }
 //listo
 public async void createDataSongVersionCloud(DataSong pDataSongVersion)
 {
     RestTools rtop = new RestTools();
     Song songop = await rtop.createVersion(pDataSongVersion);
 }
        private async void button_makeVersion_Click(object sender, RoutedEventArgs e)
        {
            DataSong selectedMeta = new DataSong();

            selectedMeta._SongDirectory = this._SongDataList[listview_data.SelectedIndex]._SongDirectory;
            selectedMeta._SongName      = this._SongDataList[listview_data.SelectedIndex]._SongName;
            selectedMeta._SongID        = this._SongDataList[listview_data.SelectedIndex]._SongID;
            selectedMeta._LocalSongID   = this._SongDataList[listview_data.SelectedIndex]._LocalSongID;
            selectedMeta._ID3Title  = textbox_title.Text;
            selectedMeta._ID3Artist = textbox_artist.Text;
            selectedMeta._ID3Genre  = textbox_genre.Text;
            selectedMeta._ID3Lyrics = textbox_lyric.Text;
            selectedMeta._ID3Album  = textbox_album.Text;
            selectedMeta._ID3Year   = textbox_year.Text;

            if (this._uploadMode == window_main.MODE_CLOUD)
            {
                this._InfoManager.createDataSongVersionCloud(selectedMeta);
                this._VersionList = await this._InfoManager.getListOfDataSong(this._SongDataList[listview_data.SelectedIndex]._SongID);
            }
            else if(this._uploadMode == window_main.MODE_LOCAL)
            {   
                this._InfoManager.createDataSongVersionLocal(selectedMeta);
                this._VersionList = this._InfoManager.getLocalVersionList(this._SongDataList[listview_data.SelectedIndex]._LocalSongID);
            }
            if (this._VersionList != null)
            {
                this.refreshVersion();
            }
        }
 public async Task<List<DataSong>> getRecomendatedSongs(string pUserName)
 {
     RestTools rtop = new RestTools();
     List<DataSong> r = new List<DataSong>();
     foreach(OtroObjeto ob in (await rtop.getRecomendatedSongs(pUserName)))
     {
         DataSong d = new DataSong();
         d._ID3Album = ob.album;
         d._ID3Artist = ob.author;
         d._ID3Genre = ob.genre;
         d._ID3Lyrics = ob.lyrics;
         d._SongID = ob.song_id.ToString();
         d._ID3Year = ob.song_year.ToString();
         d._ID3Title = ob.title;
         r.Add(d);
     }
     return r;
 }