public async Task CopyTrackToAnotherPlaylist(long playlistId, List<long> trackIds)
        {
            using (var unitOfWork = _unitOfWorkFactory.NewUnitOfWork())
            {
                var playlistTrackRepository = unitOfWork.GetRepository<PlaylistTrack>();
                var trackRepository = unitOfWork.GetRepository<Track>();

                var playlist = unitOfWork.PlaylistRepository.GetOne(pl => pl.Id == playlistId);
                var tracks = trackRepository.Get(tr => trackIds.Contains(tr.Id)).ToList();
                int i = 0;
                tracks.ForEach(track =>
                {
                    track.Playlists.Add(playlist);
                    var playlistTrack = new PlaylistTrack
                    {
                        Identifier = new PlaylistTracksIdentifier
                        {
                            Playlist = playlist,
                            Track = track,
                        },
                        TrackPosition = playlist.Tracks.Count() + i++
                    };
                    playlistTrackRepository.AddItem(playlistTrack);
                    playlist.PlaylistTracks.Add(playlistTrack);
                });

                unitOfWork.Commit();
            }
        }
        public async Task SetPlaylist(DataForTrackSaving tracksInfo, string provider, int index)
        {
            _socialNetworkApi = SocialNetworkApiFactory.GetSocialNetworkApi(provider);

            bool tracksToEnd = index == -1;

            using (var unitOfWork = _unitOfWorkFactory.NewUnitOfWork())
            {
                var playlistTrackRepository = unitOfWork.GetRepository<PlaylistTrack>();
                var trackRepository = unitOfWork.GetRepository<Track>();

                List<VkTrackResponse.Audio> trackDatas = null;
                //get checked tracks
                var socialNetworkData = GetSocialNetworkData(unitOfWork, provider);
                trackDatas = await _socialNetworkApi.GetSelectedTracks(tracksInfo, socialNetworkData.AccessToken);

                if (trackDatas.Any())
                {
                    var playlist = unitOfWork.PlaylistRepository.GetOne(pl => pl.Id == tracksInfo.PlaylistId);
                    playlist.PlaylistTracks =
                        playlistTrackRepository.Get(s => s.Identifier.Playlist.Id == tracksInfo.PlaylistId).ToList();

                    int i = 0;
                    //create Track objects
                    var artistRepo = unitOfWork.GetRepository<Artist>();

                    try
                    {
                        foreach (var trackData in trackDatas)
                        {
                            if (trackData.Artist.Length > 50)
                            {
                                trackData.Artist = trackData.Artist.Substring(0, 50);
                            }
                            if (trackData.Title.Length > 50)
                            {
                                trackData.Title = trackData.Title.Substring(0, 50);
                            }

                            var artist = new Artist
                            {
                                Name = trackData.Artist
                            };
                            var album = new Album
                            {
                                Name = "",
                                Artist = artist,
                            };

                            artist.Albums.Add(album);
                            artistRepo.AddItem(artist);

                            var track = new Track
                            {
                                Duration = trackData.Duration.ToString(CultureInfo.InvariantCulture),
                                //Lyrics =
                                //    await _socialNetworkApi.GetLyricsById(socialNetworkData.ThirdPartId, trackData.Id,
                                //            socialNetworkData.AccessToken),
                                Name = trackData.Title,
                                Album = album,
                                ThirdPartId = Convert.ToString(trackData.Id),
                                OwnerId = Convert.ToString(trackData.OwnerId),
                                Genre = trackData.GenreId.ToString(),
                            };

                            track.Playlists.Add(playlist);
                            album.Tracks.Add(track);
                            trackRepository.AddItem(track);

                            if (index == -1)
                            {
                                index = (playlist.Tracks.Any()) ? playlist.Tracks.Count() : 0;
                            }

                            var playlistTrack = new PlaylistTrack
                            {
                                Identifier = new PlaylistTracksIdentifier
                                {
                                    Playlist = playlist,
                                    Track = track
                                },
                                TrackPosition = index + i++
                            };

                            playlistTrackRepository.AddItem(playlistTrack);

                            playlist.PlaylistTracks.Add(playlistTrack);
                        }
                    }
                    catch (Exception exp)
                    {
                        var s = exp;
                    }


                    if (tracksToEnd == false)
                    {
                        playlist.PlaylistTracks.ForEach((item, n) =>
                        {
                            if (n < playlist.PlaylistTracks.Count - i && item.TrackPosition >= index)
                            {
                                item.TrackPosition += i;
                            }
                        });
                    }
                }

                unitOfWork.Commit();
            }
        }