private void OnContainerSelect(Mobile from, object target, object state)
{
if (target is Container)
{
Container cont = (Container)target;
if (!cont.IsChildOf(from.Backpack) && cont != from.Backpack)
{
from.SendMessage("You may only drop grabbed loot into containers in your pack.");
}
else
{
GrabOptions options = Grab.GetOptions(from);
GrabFlag containerFlag = Grab.ParseInt32((int)state);
options.SetPlacementContainer(containerFlag, cont);
from.SendMessage("You have selected a new container for '{0}'.", Enum.GetName(typeof(GrabFlag), containerFlag));
}
}
else
{
from.SendMessage("Loot can only be dropped into containers.");
}
from.SendGump(new GrabOptionsGump(from));
}
/// <inheritdoc />
public override async Task <GrabResult> GrabAsync(Uri uri, CancellationToken cancellationToken,
GrabOptions options)
{
// init
var id = GrabId(uri);
if (id == null)
{
return(null);
}
// generate standard Instagram link
uri = MakeStandardInstagramUri(id);
// download target page
Status.Update(null, WorkStatusType.DownloadingPage);
var client = HttpHelper.GetClient(uri);
var response = await client.GetAsync(uri, cancellationToken);
// check response
CheckResponse(response);
using var responseStream = await response.Content.ReadAsStreamAsync();
// parse page
var meta = ParsePage(responseStream);
// parse pairs
return(GrabUsingMetadata(meta));
}
public GrabOptionsGump(Mobile m)
: base(10, 10)
{
GrabOptions options = Grab.GetOptions(m);
AddPage(1);
AddBackground(0, 0, 330, 405, 9250);
AddLabel(120, 15, LabelHue, "Grab Options");
AddImageTiled(15, 35, 300, 4, 9151);
AddAlphaRegion(15, 45, 160, 20);
AddLabel(15, 45, LabelHue, "Loot to Grab");
AddAlphaRegion(180, 45, 135, 20);
AddLabel(180, 45, LabelHue, "Placement Container");
string[] types = Enum.GetNames(typeof(GrabFlag));
for (int i = 0, y = 75; i < types.Length; i++, y += 25)
{
GrabFlag flag = (GrabFlag)Enum.Parse(typeof(GrabFlag), types[i], true);
AddCheck(15, y, 210, 211, options.GetFlag(flag), (i + 1));
AddLabel(40, y, LabelHue, types[i]);
AddLabelCropped(185, y, 100, 20, LabelHue, Grab.GetContainerName(m, flag));
AddButton(295, y, 9762, 9763, (i + 1), GumpButtonType.Reply, 0);
}
AddButton(15, 370, 4020, 4022, 100, GumpButtonType.Reply, 0);
AddLabel(50, 370, LabelHue, "Cancel");
AddButton(285, 370, 4023, 4025, 105, GumpButtonType.Reply, 0);
AddLabel(190, 370, LabelHue, "Apply Changes");
}
protected virtual void Grab(GrabResult result, JObject vars, GrabOptions options)
{
if (options.Flags.HasFlag(GrabOptionFlag.GrabImages))
{
var image_url = new Uri(result.OriginalUri, vars.SelectToken("$.image_url").Value <string>());
result.Resources.Add(new GrabbedImage(GrabbedImageType.Primary, null, image_url));
}
result.Title = vars.SelectToken("$.video_title").Value <string>();
result.Statistics = new GrabStatisticInfo();
result.Statistics.Length = TimeSpan.FromSeconds(vars.SelectToken("$.video_duration").Value <int>());
var qualities = vars.SelectTokens("$.defaultQuality[*]").Select(t => t.Value <int>()).ToArray();
foreach (var quality in qualities)
{
var key = $"quality_{quality}p";
var url = vars.SelectToken($"$.{key}")?.Value <string>();
if (string.IsNullOrEmpty(url))
{
continue;
}
var vid = new GrabbedMedia(new Uri(result.OriginalUri, url), null, new MediaFormat("video/mp4", "mp4"), MediaChannels.Both);
vid.Resolution = $"{quality}p";
vid.FormatTitle = $"MP4 {vid.Resolution}";
result.Resources.Add(vid);
}
}
private Task <GrabResult> GrabAsync(Uri uri, PlaylistDocument doc, CancellationToken cancellationToken,
GrabOptions options)
{
// get resources
IList <IGrabbed> grabs;
if (doc.Streams.Count > 0)
{
grabs = GrabStreams(uri, doc);
}
else if (doc.Segments.Count > 0)
{
grabs = GrabSegments(uri, doc);
}
else
{
grabs = null;
}
// make result
var result = new GrabResult(uri, grabs);
if (options.Flags.HasFlag(GrabOptionFlag.Decrypt) && doc.Key != null)
{
UpdateDecryptionMethod(result, doc.Key);
}
return(Task.FromResult(result));
}
private static void GrabLoot(Mobile from, Container cont)
{
if (!from.Alive || cont == null)
{
return;
}
if (cont is Corpse && from == ((Corpse)cont).Owner)
{
Corpse corpse = (Corpse)cont;
if (corpse.Killer == null || corpse.Killer is BaseCreature)
{
corpse.Open(from, true);
}
else
{
corpse.Open(from, false);
}
}
else
{
bool fullPack = false;
List <Item> items = new List <Item>(cont.Items);
GrabOptions options = Grab.GetOptions(from);
for (int i = 0; !fullPack && i < items.Count; i++)
{
Item item = items[i];
if (options.IsLootable(item))
{
Container dropCont = options.GetPlacementContainer(Grab.ParseType(item));
if (dropCont == null || dropCont.Deleted || !dropCont.IsChildOf(from.Backpack))
{
dropCont = from.Backpack;
}
if (!item.DropToItem(from, dropCont, new Point3D(-1, -1, 0)))
{
fullPack = true;
}
}
}
if (fullPack)
{
from.SendMessage("You grabbed as many of the items as you could. The rest remain {0}.", (cont is Corpse ? "on the corpse" : "in the container"));
}
else
{
from.SendMessage("You retrieve all of the items from the {0}.", (cont is Corpse ? "body" : "container"));
}
from.RevealingAction();
}
}
public override void OnResponse(Server.Network.NetState sender, RelayInfo info)
{
Mobile m = sender.Mobile;
GrabOptions options = Grab.GetOptions(m);
if (m == null || info.ButtonID <= 0 || info.ButtonID == 100)
{
return;
}
//store flags
options.ResetFlags();
if (info.Switches.Length > 0)
{
for (int i = 0; i < info.Switches.Length; i++)
{
if (info.Switches[i] == 1)
{
options.SetFlag(GrabFlag.Everything, true);
break;
}
options.SetFlag(Grab.ParseInt32(info.Switches[i]), true);
}
}
else
{
options.SetFlag(GrabFlag.Everything, true);
}
//handle buttons
if (info.ButtonID == 105) //OK
{
Grab.SaveOptions(m, options);
m.SendMessage("You have updated your Grab options.");
}
else //placement container selection
{
m.SendMessage("Select the container to place this type of loot in.");
m.BeginTarget(-1, false, Server.Targeting.TargetFlags.None, new TargetStateCallback(OnContainerSelect), info.ButtonID);
}
}
protected virtual void Grab(GrabResult result, JObject flashVars, JArray qualityItemVars, GrabOptions options)
{
var grabbed = new Dictionary <int, GrabbedMedia>();
if (options.Flags.HasFlag(GrabOptionFlag.GrabImages))
{
var image_url = new Uri(result.OriginalUri, flashVars.SelectToken("$.image_url").Value <string>());
result.Resources.Add(new GrabbedImage(GrabbedImageType.Primary, null, image_url));
}
result.Title = flashVars.SelectToken("$.video_title").Value <string>();
result.Statistics = new GrabStatisticInfo
{
Length = TimeSpan.FromSeconds(flashVars.SelectToken("$.video_duration").Value <int>())
};
if (qualityItemVars != null && qualityItemVars.Count > 0)
{
foreach (var quality in qualityItemVars)
{
var url = quality.Value <string>("url");
if (string.IsNullOrEmpty(url))
{
continue;
}
var vid = new GrabbedMedia(new Uri(result.OriginalUri, url), result.OriginalUri, DefaultMediaFormat, MediaChannels.Both);
vid.Resolution = quality.Value <string>("text");
var qint = StringHelper.ForceParseInt(vid.Resolution);
grabbed.Add(qint, vid);
}
}
var mediaDefinitions = flashVars.SelectToken("$.mediaDefinitions");
foreach (var def in mediaDefinitions)
{
var format = def.Value <string>("format");
var url = def.Value <string>("videoUrl");
var isQualityArr = def["quality"] is JArray;
var qualityArr = isQualityArr ? def["quality"].Values <int>().ToArray() : null;
var quality = isQualityArr ? 0 : StringHelper.ForceParseInt(def.Value <string>("quality"));
if (grabbed.ContainsKey(quality) || string.IsNullOrEmpty(url))
{
continue;
}
if (isQualityArr && qualityArr.Length == 0)
{
continue;
}
var uri = new Uri(result.OriginalUri, url);
var resol = isQualityArr ? null : $"{quality}p";
var playlistType = isQualityArr ? HlsPlaylistType.Master : HlsPlaylistType.Stream;
switch (format.ToLowerInvariant())
{
case "mp4":
var m = new GrabbedMedia(uri, result.OriginalUri, DefaultMediaFormat, MediaChannels.Both)
{
Resolution = resol,
FormatTitle = $"MP4 {resol}",
};
grabbed.Add(quality, m);
break;
case "hls":
var sr = new GrabbedStreamReference(uri, result.OriginalUri)
{
Resolution = resol,
PlaylistType = playlistType,
};
result.Resources.Add(sr);
break;
default:
continue;
}
}
foreach (var g in grabbed.OrderByDescending(m => m.Key))
{
result.Resources.Add(g.Value);
}
}
public override async Task <GrabResult> GrabAsync(Uri uri, CancellationToken cancellationToken, GrabOptions options)
{
if (!Supports(uri))
{
return(null);
}
using var client = HttpHelper.CreateClient(uri);
var content = await client.GetStringAsync(uri).ConfigureAwait(false);
var result = new GrabResult(uri);
var paramMap = ParsePage(content, result);
// grab info
result.Title = paramMap.GetOrDefault("title")?.ToString();
result.Statistics = new GrabStatisticInfo
{
Length = TimeSpan.FromSeconds(Convert.ToDouble(paramMap.GetOrDefault("duration"))),
};
// grab images
var img = (paramMap.GetOrDefault("image") ?? paramMap.GetOrDefault("ThumbUrl169") ?? paramMap.GetOrDefault("ThumbUrl")) as string;
if (Uri.TryCreate(img, UriKind.Absolute, out var imgUri))
{
result.Resources.Add(new GrabbedImage(GrabbedImageType.Thumbnail, uri, imgUri));
}
img = (paramMap.GetOrDefault("ThumbSlideBig") ?? paramMap.GetOrDefault("ThumbSlide")) as string;
if (Uri.TryCreate(img, UriKind.Absolute, out imgUri))
{
result.Resources.Add(new GrabbedImage(GrabbedImageType.Preview, uri, imgUri));
}
// grab resources
var hls = paramMap["VideoHLS"] as string;
if (string.IsNullOrEmpty(hls))
{
throw new GrabParseException("Could not locate the HLS playlist file.");
}
var hlsUri = new Uri(hls);
var hlsGrabber = new HlsGrabber();
var hlsGrabResult = await hlsGrabber.GrabAsync(hlsUri, cancellationToken, options).ConfigureAwait(false);
foreach (var resource in hlsGrabResult.Resources)
{
result.Resources.Add(resource);
}
return(result);
}
/// <inheritdoc />
public override async Task <GrabResult> GrabAsync(Uri uri, CancellationToken cancellationToken, GrabOptions options)
{
// grab view id
var viewId = GetViewId(uri);
if (viewId == null)
{
return(null);
}
uri = MakeStandardUri(viewId);
using (var client = HttpHelper.CreateClient())
{
// download content
var response = await client.GetAsync(uri, cancellationToken);
response.EnsureSuccessStatusCode();
var htmlContent = await response.Content.ReadAsStringAsync();
// cut the useful part of htmlContent to speed up regex look up
htmlContent = CutUsefulPart(htmlContent);
// grab javascript flashvars
var match = FlashVarsFinder.Match(htmlContent);
if (!match.Success)
{
throw new GrabParseException("Failed to locate flashvars.");
}
var variableName = match.Groups[3].Value;
var flashVars = await ExtractFlashVars(match.Groups[1].Value, variableName);
// generate result
var result = new GrabResult(uri);
Grab(result, flashVars, options);
return(result);
}
}
/// <inheritdoc />
public sealed override async Task <GrabResult> GrabAsync(Uri uri, CancellationToken cancellationToken, GrabOptions options)
{
// get YouTube ID
var id = GetYouTubeId(uri);
if (string.IsNullOrEmpty(id))
{
return(null);
}
// generate original link
var originalUri = GetYouTubeStandardUri(id);
// prepare result
var result = new GrabResult(originalUri);
// grab using the internal grab method
await GrabAsync(result, id, cancellationToken, options);
return(result);
}
/// <inheritdoc />
protected override async Task GrabAsync(GrabResult result, string id, CancellationToken cancellationToken, GrabOptions options)
{
// extract base.js script
var embedPageData = await DownloadEmbedPage(id);
// download metadata
var metaData = await DownloadMetadata(id, cancellationToken);
// update result according to the metadata
UpdateResult(result, metaData);
// are there any encrypted streams?
result.IsSecure = metaData.AllStreams.Any(stream => !string.IsNullOrEmpty(stream.Signature));
// should we decipher the signature?
if (result.IsSecure && options.Flags.HasFlag(GrabOptionFlag.Decipher))
{
await Decipher(embedPageData, metaData, cancellationToken);
}
// append images to the result
if (options.Flags.HasFlag(GrabOptionFlag.GrabImages))
{
AppendImagesToResult(result, id);
}
// append muxed streams to result
foreach (var stream in metaData.MuxedStreams)
{
AppendStreamToResult(result, stream);
}
// append adaptive streams to result
foreach (var stream in metaData.AdaptiveStreams)
{
AppendStreamToResult(result, stream);
}
}
/// <summary> /// This method gets called internally by <see cref="GrabAsync(Uri, CancellationToken, GrabOptions)"/> after necessary initializations. /// </summary> protected abstract Task GrabAsync(GrabResult result, string id, CancellationToken cancellationToken, GrabOptions options);
/// <summary>
/// Write ID3 tags for a file
/// </summary>
/// <param name="FilePath">The file path to write</param>
/// <param name="Id3Info">ID3 tags</param>
/// <param name="Options">Options (whether need to write info, cover, lyrics)</param>
public static void WriteFile(string FilePath, Id3 Id3Info, GrabOptions Options)
{
TagLib.File trackFile = TagLib.File.Create(FilePath);
trackFile.RemoveTags(TagLib.TagTypes.Id3v1);
trackFile.RemoveTags(TagLib.TagTypes.Ape);
TagLib.Id3v2.Tag.DefaultVersion = 3;
TagLib.Id3v2.Tag.ForceDefaultVersion = true;
if (Options.needId3)
{
trackFile.Tag.Album = Id3Info.AlbumTitle;
trackFile.Tag.AlbumArtists = Id3Info.AlbumArtists;
trackFile.Tag.Title = Id3Info.TrackName;
trackFile.Tag.Performers = Id3Info.Performers;
trackFile.Tag.Year = Id3Info.Year;
trackFile.Tag.Disc = Id3Info.Disc;
trackFile.Tag.DiscCount = Id3Info.DiscCount;
trackFile.Tag.Track = Id3Info.Track;
trackFile.Tag.TrackCount = Id3Info.TrackCount;
}
if (Options.needCover)
{
trackFile.Tag.Pictures = Id3Info.CoverImageList.ToArray();
}
if (Options.needLyric)
{
trackFile.Tag.Lyrics = Id3Info.Lyrics;
}
trackFile.Save();
}
/// <inheritdoc />
public override async Task <GrabResult> GrabAsync(Uri uri, CancellationToken cancellationToken, GrabOptions options)
{
// grab view id
var viewId = GetViewId(uri);
if (viewId == null)
{
return(null);
}
uri = MakeStandardUri(viewId);
using var client = HttpHelper.GetClient();
// download content
var response = await client.GetAsync(uri, cancellationToken);
response.EnsureSuccessStatusCode();
var htmlContent = await response.Content.ReadAsStringAsync();
// cut the useful part of htmlContent to speed up regex look up
htmlContent = CutUsefulPart(htmlContent);
var objListIndex = htmlContent.IndexOf("playerObjList.");
if (objListIndex < 0)
{
throw new GrabParseException("Could not find the video.");
}
htmlContent = htmlContent.Insert(objListIndex, "var playerObjList = {};\r\n");
// grab javascript flashvars
var flashVarsMatch = FlashVarsFinder.Match(htmlContent);
if (!flashVarsMatch.Success)
{
throw new GrabParseException("Failed to locate flashvars.");
}
var qualityVarsMatch = QualityItemsVarFinder.Match(htmlContent);
if (!qualityVarsMatch.Success)
{
throw new GrabParseException("Failed to locate qualityItems.");
}
var flashVarsVariableName = flashVarsMatch.Groups[3].Value;
var qualityItemsVariableName = qualityVarsMatch.Groups[3].Value;
var(flashVars, qualityItems) = await ExtractFlashVars(flashVarsMatch.Groups[1].Value, flashVarsVariableName,
qualityItemsVariableName);
// generate result
var result = new GrabResult(uri);
Grab(result, flashVars, qualityItems, options);
return(result);
}
public override async Task <GrabResult> GrabAsync(Uri uri, CancellationToken cancellationToken, GrabOptions options)
{
using var client = HttpHelper.GetClient(uri);
using var response = await client.GetAsync(uri, cancellationToken).ConfigureAwait(false);
response.EnsureSuccessStatusCode();
using var responseStream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
var doc = new PlaylistDocument();
try
{
await doc.LoadAsync(responseStream).ConfigureAwait(false);
}
catch (PlaylistDocumentLoadException loadException)
{
throw new GrabException("Failed to load the M3U8 playlist.", loadException);
}
return(await GrabAsync(uri, doc, cancellationToken, options).ConfigureAwait(false));
}
/// <inheritdoc />
public override async Task <GrabResult> GrabAsync(Uri uri, CancellationToken cancellationToken, GrabOptions options)
{
// init
var id = GrabId(uri);
if (id == null)
{
return(null);
}
var configUri = new Uri($"https://player.vimeo.com/video/{id}/config");
// download target page
Status.Update(null, WorkStatusType.DownloadingPage);
var client = HttpHelper.GetClient(configUri);
var response = await client.GetAsync(configUri, cancellationToken);
// check response
CheckResponse(response);
// parse the config
var config = await GetConfigurationAsync(response.Content);
// create the grab result
return(GrabUsingConfiguration(config, uri));
}
