private void OnLinkInputChanged(object sender, EventArgs e)
{
string link = mUrlInput.Text;
string normalizedLink;
mDownloadButton.Enabled = DownloadUrlResolver.TryNormalizeYoutubeUrl(link, out normalizedLink);
}
private Tuple <bool, string> ValidateLink()
{
//Contains the normalized URL
string normalUrl;
Tuple <bool, string> tuple = null;
//Checks that a valid folder is entered to store downloaded files
if (!Directory.Exists(this.tbxDownloadPath.Text))
{
if (!this.CheckLocalPath())
{
tuple = Tuple.Create(false, "");
}
}
//Checks that URL entered corresponds to a valid Youtube video
else if (!(DownloadUrlResolver.TryNormalizeYoutubeUrl(this.tbxYoutubeUrl.Text, out normalUrl)))
{
this.tbxYoutubeUrl.Focus();
MessageBox.Show(this, "올바른 Youtube URL을 입력하세요.", ConstValue.MSGBOX_TITLE, MessageBoxButtons.OK, MessageBoxIcon.Warning);
tuple = Tuple.Create(false, "");
}
else
{
tuple = Tuple.Create(true, normalUrl);
}
return(tuple);
}
public void GetNormalizedYouTubeUrlForBadLinkShouldReturnNull()
{
string url = "http://notAYouTubeUrl.com";
string normalizedUrl = String.Empty;
Assert.IsFalse(DownloadUrlResolver.TryNormalizeYoutubeUrl(url, out normalizedUrl));
Assert.IsNull(normalizedUrl);
}
public void TryNormalizedrlForYouTuDotBeUrlShouldReturnNormalizedUrl()
{
string url = "http://youtu.be/12345";
string normalizedUrl = String.Empty;
Assert.IsTrue(DownloadUrlResolver.TryNormalizeYoutubeUrl(url, out normalizedUrl));
Assert.AreEqual("http://youtube.com/watch?v=12345", normalizedUrl);
}
public void TryNormalizedUrlForStandardYouTubeUrlShouldReturnSame()
{
var urlResolver = new DownloadUrlResolver();
string url = "http://youtube.com/watch?v=12345";
string normalizedUrl = String.Empty;
Assert.True(urlResolver.TryNormalizeYoutubeUrl(url, out normalizedUrl));
Assert.Equal(url, normalizedUrl);
}
public void TryNormalizedUrlForMobileLinkShouldReturnNormalizedUrl()
{
var urlResolver = new DownloadUrlResolver();
string url = "http://m.youtube.com/?v=12345";
string normalizedUrl = String.Empty;
Assert.True(urlResolver.TryNormalizeYoutubeUrl(url, out normalizedUrl));
Assert.Equal("http://youtube.com/watch?v=12345", normalizedUrl);
}
public static bool IsYoutube(string url)
{
try{
var videoUrl = url;
var isYoutubeUrl = DownloadUrlResolver.TryNormalizeYoutubeUrl(videoUrl, out videoUrl);
return(isYoutubeUrl);
}
catch (Exception ex) {
Console.WriteLine(ex);
}
return(false);
}
private List <Post> GetRedditPosts(Options options)
{
//reddit show top vidoes for week
var reddit = new Reddit(options.username, options.password);
var subreddit = reddit.GetSubreddit(options.subreddit);
var listings = new List <Listing <Post> >();
switch (options.sort)
{
case Options.ListingType.Hot:
listings.Add(subreddit.Hot);
break;
case Options.ListingType.New:
listings.Add(subreddit.New);
break;
case Options.ListingType.Top:
listings.Add(subreddit.GetTop(options.timespan));
break;
case Options.ListingType.All:
listings.Add(subreddit.GetTop(options.timespan));
listings.Add(subreddit.Hot);
listings.Add(subreddit.New);
break;
}
var progress = "";
for (int i = 0; i < listings.Count(); i++)
{
progress += "-";
}
Console.WriteLine(progress);
var posts = new List <Post>();
foreach (var listing in listings)
{
var selected = listing.Take(options.count)
.Where(x => (x.CommentCount >= options.commentThreshold && x.Upvotes >= options.upvoteThreshold && x.NSFW == options.NSFW) || x.Liked == true)
.Where(x => DownloadUrlResolver.TryNormalizeYoutubeUrl(x.Url.ToString(), out _));
posts.AddRange(selected);
Console.Write("=");
}
Console.WriteLine();
posts = posts.GroupBy(x => x.Id).Select(g => g.First()).ToList();
return(posts);
}
public void UrlsAreIgnoredCorrectly()
{
string[] urls =
{
"http://notAYouTubeUrl.com"
};
foreach (var url in urls)
{
string normalizedUrl;
Assert.IsFalse(DownloadUrlResolver.TryNormalizeYoutubeUrl(url, out normalizedUrl));
}
}
static void CompileThis()
{
AdaptiveType a = AdaptiveType.Audio;
a = AdaptiveType.None;
a = AdaptiveType.Video;
AudioExtractionException b = new AudioExtractionException(default(string));
AudioType c = AudioType.Aac;
c = AudioType.Mp3;
c = AudioType.Unknown;
c = AudioType.Vorbis;
DownloadUrlResolver.DecryptDownloadUrl(default(VideoInfo));
IEnumerable <VideoInfo> d = DownloadUrlResolver.GetDownloadUrls(default(string));
d = DownloadUrlResolver.GetDownloadUrls(default(string), default(bool));
string e = default(string);
bool f = DownloadUrlResolver.TryNormalizeYoutubeUrl(e, out e);
VideoInfo g = default(VideoInfo);
AdaptiveType h = g.AdaptiveType;
int i = g.AudioBitrate;
string j = g.AudioExtension;
AudioType k = g.AudioType;
bool l = g.CanExtractAudio;
string m = g.DownloadUrl;
int n = g.FormatCode;
bool o = g.Is3D;
bool p = g.RequiresDecryption;
int q = g.Resolution;
string r = g.Title;
string s = g.VideoExtension;
VideoType t = g.VideoType;
VideoNotAvailableException u = new VideoNotAvailableException();
u = new VideoNotAvailableException(default(string));
VideoType v = VideoType.Flash;
v = VideoType.Mobile;
v = VideoType.Mp4;
v = VideoType.Unknown;
v = VideoType.WebM;
YoutubeParseException w = new YoutubeParseException(default(string), default(Exception));
}
private Tuple <bool, string> ValidateLink()
{
string normalURL;
if (DownloadUrlResolver.TryNormalizeYoutubeUrl(txtLink.Text, out normalURL))
{
return(Tuple.Create(true, normalURL));
}
else
{
MessageBox.Show("Please enter a valid YouTube link.");
return(Tuple.Create(false, ""));
}
}
/// <summary>
/// Gets the MRLS.
/// </summary>
/// <param name="url">The URL.</param>
/// <returns></returns>
public static IEnumerable <string> GetMrls(string url)
{
var normalizedUrl = string.Empty;
if (DownloadUrlResolver.TryNormalizeYoutubeUrl(url, out normalizedUrl))
{
var videoInfos = DownloadUrlResolver.GetDownloadUrls(normalizedUrl);
foreach (var item in videoInfos)
{
yield return(item.DownloadUrl);
}
}
}
//Tuple returns true if the link is good, the string returned is the valid link to the video
private Tuple <bool, string> ValidateLink()
{
//Contains the normalized URL
string normalUrl;
//Checks that URL entered corresponds to a valid Youtube video
if (!(DownloadUrlResolver.TryNormalizeYoutubeUrl(txtLink.Text, out normalUrl)))
{
Label2.Text = "Please enter a valid Youtube link";
return(Tuple.Create(false, ""));
}
else
{
return(Tuple.Create(true, normalUrl));
}
}
private Tuple <bool, string> ValidateLink()
{
string normalURL;//normalized URL from YouTube
if (!Directory.Exists(txtDownloadFolder.Text))
{
MessageBox.Show("Please enter a valid folder."); //block runs when folder cannot be found
return(Tuple.Create(false, ""));
}
else if (DownloadUrlResolver.TryNormalizeYoutubeUrl(txtLink.Text, out normalURL))
{
return(Tuple.Create(true, normalURL));//return true and actual link if successful
}
else
{
MessageBox.Show("Please enter a valid YouTube link.");
return(Tuple.Create(false, ""));//return nothing if the link is not good
}
}
private void OnFocus(object sender, EventArgs e)
{
if (mSettings.AutoURLClipboardCopy && string.IsNullOrEmpty(mUrlInput.Text))
{
string text = Clipboard.GetText();
string downloadUrl = (mTask.CurrentVideo != null ? mTask.CurrentVideo.Info.DownloadUrl : null);
string normalized;
if (DownloadUrlResolver.TryNormalizeYoutubeUrl(text, out normalized))
{
if (mAlreadyDownloadedUrls.Contains(normalized))
{
return;
}
mUrlInput.Text = text;
}
}
}
public void UrlsAreNormalizedCorrectly()
{
var targetUrl = "http://youtube.com/watch?v=12345";
string[] urls =
{
"http://youtube.com/watch?v=12345",
"http://youtu.be/12345",
"http://m.youtube.com/?v=12345",
"http://m.youtube.com/?v=12345&hawd"
};
foreach (var url in urls)
{
string normalizedUrl;
Assert.IsTrue(DownloadUrlResolver.TryNormalizeYoutubeUrl(url, out normalizedUrl));
Assert.AreEqual(targetUrl, normalizedUrl);
}
}
public IActionResult Index()
{
ViewData["Title"] = "Book";
ViewData["Paused"] = ServiceLocator.Musicplayer.IsPaused;
try
{
string youtubeLink = Request.Form.ElementAt(0).Value.ElementAt(0);
string userName = Request.Form.ElementAt(1).Value.ElementAt(0).ToLower();
string videoUrl = youtubeLink;
bool isYoutubeUrl = DownloadUrlResolver.TryNormalizeYoutubeUrl(videoUrl, out videoUrl);
if (string.IsNullOrWhiteSpace(youtubeLink) || string.IsNullOrWhiteSpace(userName) || !isYoutubeUrl)
{
ViewData["ErrorMessage"] = "Dulli!";
return(View());
}
User user = this.userManager.Users.Where(x => x.Name == userName).FirstOrDefault();
if (user != null)
{
user.YoutubeLinks.Add(new YoutubeFile {
Url = youtubeLink
});
}
else
{
this.userManager.Users.Add(new User(userName, new YoutubeFile {
Url = youtubeLink
}));
}
}
catch (Exception)
{
// No body was sent
}
return(View());
}
//Tuple returns true if the link is good, the string returned is the valid link to the video
private Tuple <bool, string> ValidateLink()
{
//Contains the normalized URL
string normalUrl;
//Checks that a valid folder is entered to store downloaded files
if (!Directory.Exists(txtPath.Text))
{
MessageBox.Show("Please enter a valid folder");
return(Tuple.Create(false, ""));
}
//Checks that URL entered corresponds to a valid Youtube video
else if (!(DownloadUrlResolver.TryNormalizeYoutubeUrl(txtLink.Text, out normalUrl)))
{
MessageBox.Show("Please enter a valid Youtube link");
return(Tuple.Create(false, ""));
}
else
{
return(Tuple.Create(true, normalUrl));
}
}
private Tuple <bool, string> ValidateInput()
{
string resultURL;
var validURL = DownloadUrlResolver.TryNormalizeYoutubeUrl(txtYouTubeURL.Text, out resultURL);
var validFolderPath = Directory.Exists(txtDownloadPath.Text);
if (!validFolderPath)
{
lblValidation.Text = "Invalid Folder Path";
lblValidation.ForeColor = Color.Red;
return(Tuple.Create(false, ""));
}
if (!validURL)
{
lblValidation.Text = "Invalid URL";
lblValidation.ForeColor = Color.Red;
return(Tuple.Create(false, ""));
}
lblValidation.Text = "Valid URL / Folder Path";
lblValidation.ForeColor = Color.Green;
return(Tuple.Create(true, resultURL));
}
private void WireDragAndDrop()
{
var playlistDropEvent = this.PlaylistListBox.ItemContainerStyle.RegisterEventSetter <DragEventArgs>(DropEvent, x => new DragEventHandler(x))
.Merge(this.PlaylistListBox.Events().Drop.Select(x => Tuple.Create((object)null, x)));
// Local, YouTube and SoundCloud songs
playlistDropEvent
.Where(x => x.Item2.Data.GetDataPresent(DataFormats.StringFormat) && (string)x.Item2.Data.GetData(DataFormats.StringFormat) == DragDropHelper.SongSourceFormat)
.Subscribe(x =>
{
int?targetIndex = x.Item1 == null ? (int?)null : ((PlaylistEntryViewModel)((ListBoxItem)(x.Item1)).DataContext).Index;
var addCommand = this.shellViewModel.CurrentSongSource.AddToPlaylistCommand;
if (addCommand.CanExecute(null))
{
addCommand.Execute(targetIndex);
}
x.Item2.Handled = true;
});
// YouTube links (e.g from the browser)
playlistDropEvent
.Where(x => x.Item2.Data.GetDataPresent(DataFormats.StringFormat))
.Where(x =>
{
var url = (string)x.Item2.Data.GetData(DataFormats.StringFormat);
Uri uriResult;
bool result = Uri.TryCreate(url, UriKind.Absolute, out uriResult) && (uriResult.Scheme == Uri.UriSchemeHttp || uriResult.Scheme == Uri.UriSchemeHttps);
string urlDontCare;
return(result && DownloadUrlResolver.TryNormalizeYoutubeUrl(url, out urlDontCare));
})
.SelectMany(async x =>
{
var url = (string)x.Item2.Data.GetData(DataFormats.StringFormat);
int?targetIndex = x.Item1 == null ? (int?)null : ((PlaylistEntryViewModel)((ListBoxItem)(x.Item1)).DataContext).Index;
if (this.shellViewModel.DirectYoutubeViewModel.AddToPlaylistCommand.CanExecute(null))
{
await this.shellViewModel.DirectYoutubeViewModel.AddDirectYoutubeUrlToPlaylist(new Uri(url), targetIndex);
}
x.Item2.Handled = true;
return(Unit.Default);
}).Subscribe();
// Moving items inside the playlist
const string movePlaylistSongFormat = "MovePlaylistSong";
this.PlaylistListBox.ItemContainerStyle.RegisterEventSetter <MouseEventArgs>(MouseMoveEvent, x => new MouseEventHandler(x))
.Where(x => x.Item2.LeftButton == MouseButtonState.Pressed && this.shellViewModel.CurrentPlaylist.SelectedEntries.Any())
.Subscribe(x => DragDrop.DoDragDrop((ListBoxItem)x.Item1, movePlaylistSongFormat, DragDropEffects.Move));
playlistDropEvent
.Where(x => x.Item2.Data.GetDataPresent(DataFormats.StringFormat) && (string)x.Item2.Data.GetData(DataFormats.StringFormat) == movePlaylistSongFormat)
.Subscribe(x =>
{
if (this.shellViewModel.CurrentPlaylist.MovePlaylistSongCommand.CanExecute(null))
{
int?targetIndex = x.Item1 == null ? (int?)null : ((PlaylistEntryViewModel)((ListBoxItem)(x.Item1)).DataContext).Index;
this.shellViewModel.CurrentPlaylist.MovePlaylistSongCommand.Execute(targetIndex);
}
x.Item2.Handled = true;
});
}
private void OnDownloadClicked(object sender, EventArgs e)
{
string link = mUrlInput.Text;
string normalizedLink;
if (!DownloadUrlResolver.TryNormalizeYoutubeUrl(link, out normalizedLink))
{
throw new ArgumentException("the download button should be disabled by now!");
}
VideoInfo video = null;
Exception bwError = null;
ProgressBox progBox = new ProgressBox();
progBox.ProgressText = "Search video...";
BackgroundWorker bw = new BackgroundWorker();
bw.DoWork += (ev, args) =>
{
var videos = DownloadUrlResolver.GetDownloadUrls(link);
video = videos.Where(info => info.CanExtractAudio)
.OrderByDescending(info => info.AudioBitrate)
.FirstOrDefault();
};
bw.RunWorkerCompleted += (ev, args) =>
{
if (args.Error != null)
{
bwError = args.Error;
progBox.DialogResult = DialogResult.Abort;
}
else if (args.Cancelled)
{
progBox.DialogResult = DialogResult.Cancel;
}
else
{
progBox.DialogResult = DialogResult.OK;
}
};
bw.RunWorkerAsync();
switch (progBox.ShowDialog(this))
{
case DialogResult.Cancel:
return;
case DialogResult.OK:
if (video != null)
{
break;
}
goto case DialogResult.Abort;
case DialogResult.Abort:
MessageBox.Show(this, "Failed to get download url!\n" + (bwError != null? bwError.ToString() : "No reason!"), "Error while searching Youtube!");
return;
}
DownloadVideo dvideo = null;
if (mSettings.UseTagEditor)
{
TagEditor tagEditor = new TagEditor();
tagEditor.SetFieldsFromTitle(video.Title);
tagEditor.StartPosition = FormStartPosition.CenterParent;
if (tagEditor.ShowDialog(this) == System.Windows.Forms.DialogResult.OK)
{
dvideo = new DownloadVideo(tagEditor.Title, tagEditor.Artist, video);
}
else
{
return;
}
}
else
{
dvideo = new DownloadVideo(video.Title, "", video);
}
mAlreadyDownloadedUrls.Add(normalizedLink);
mUrlInput.Text = "";
mReportBox.AppendText("Add video to pending: " + video.Title + "\n");
mTask.AddVideo(dvideo);
mStopButton.Text = "Stop";
FillListView();
}
void DisplayClipboardData()
{
try
{
var videoUrl = (string)Clipboard.GetData(DataFormats.Text);
bool isYoutubeUrl = DownloadUrlResolver.TryNormalizeYoutubeUrl(videoUrl, out videoUrl);
var select = new frmDownloadDialog(videoUrl);
Form fc = Application.OpenForms[select.Name];//multipe time opening bug fixed
if (fc == null)
{
if (isYoutubeUrl)
{
Url = videoUrl;
switch (select.ShowDialog())
{
case DialogResult.OK:
if (TubeDlHelpers.Combine)
{
if (TubeDlHelpers.Custome)
{
Download(TubeDlHelpers.downloadurl,
true, Path.GetDirectoryName(TubeDlHelpers.customSavePath), TubeDlHelpers.customeSavefileName);
Download(TubeDlHelpers.downloadurl,
true, Path.GetDirectoryName(TubeDlHelpers.customSavePath), TubeDlHelpers.customeSavefileName.Replace(".mp4", ".mp3"));
combineid++;
}
else
{
string vname = StringHelpers.RemoveIllegalPathCharacters(TubeDlHelpers.video.Title)
+ " " + (TubeDlHelpers.video.Resolution == 0 ? "" : TubeDlHelpers.video.Resolution.ToString() + "p") + ".mp4";
string aname = StringHelpers.RemoveIllegalPathCharacters(TubeDlHelpers.video.Title)
+ " " + (TubeDlHelpers.video.Resolution == 0 ? "" : TubeDlHelpers.video.Resolution.ToString() + "p") + ".mp3";
Download(TubeDlHelpers.downloadurl,
true, TubeDlHelpers.SavePath, vname);
Download(TubeDlHelpers.downloadurl,
true, TubeDlHelpers.SavePath, aname);
combineid++;
}
}
else if (TubeDlHelpers.Custome)
{
Download(TubeDlHelpers.downloadurl, true, Path.GetDirectoryName(TubeDlHelpers.customSavePath), TubeDlHelpers.customeSavefileName);
}
else
{
Download(TubeDlHelpers.downloadurl);
}
break;
case DialogResult.Ignore:
if (TubeDlHelpers.Custome)
{
Download(TubeDlHelpers.downloadurl, true, Path.GetDirectoryName(TubeDlHelpers.customSavePath), TubeDlHelpers.customeSavefileName);
}
else
{
Download(TubeDlHelpers.downloadurl);
}
TubeDlHelpers.ldf[list_Items.Items.Count - 1].CancelDownload();
break;
}
}
}
}
catch (Exception e)
{
#if DEBUG
// MessageBox.Show(e.Message);
#endif
}
}
bool IStreamResolver.SyncCanResolve(string input)
{
string dummy;
return(DownloadUrlResolver.TryNormalizeYoutubeUrl(input, out dummy));
}