Пример #1
0
        protected override void OnNavigatedTo(NavigationEventArgs e)
        {
            base.OnNavigatedTo(e);
            NavigationMode = e.NavigationMode;
            if (e.NavigationMode == NavigationMode.New)
            {
                GetType().RemovePageFromBackStack();
            }

            try
            {
                if (e.Parameter is InstaMedia media)
                {
                    MediaPrivate         = /*ToPost*/ (media);
                    MediaIdOrLINKPrivate = null;
                }
                else if (e.Parameter is string mediaIdOrLink)
                {
                    MediaIdOrLINKPrivate = mediaIdOrLink;
                    MediaPrivate         = null;
                    //HandleLinkOrMediaId(mediaIdOrLink);
                }
            }
            catch { }
        }
        public InstaMediaContentDialog(InstaMedia Media)
        {
            this.InitializeComponent();
            this.DataContext = Media;
            _med             = Media;
#if !DEBUG
            if (!Media.User.IsPrivate || Media.PhotoOfYou || Media.User.UserName == AppCore.InstaApi.GetLoggedUser().UserName)
            {
#endif
            Commands.Items.Add(new LVItem {
                Text = "Copy URL", Tag = "Copy"
            });
            Commands.Items.Add(new LVItem {
                Text = "Download content", Tag = "Download"
            });
#if !DEBUG
        }
#endif
            Commands.Items.Add(new LVItem {
                Text = "Copy caption", Tag = "CC"
            });
            Commands.Items.Add(new LVItem {
                Text = "Cancel", Tag = "Cancel"
            });
        }
Пример #3
0
        public async Task Execute(Queue queue, InstaBotContext db)
        {
            var  allGroups     = queue.LoadId.Split(' ');
            bool isMediaPosted = false;

            foreach (var group in allGroups)
            {
                var instaMediaList = await _instaApi.GetUserMediaAsync(group, PaginationParameters.MaxPagesToLoad(0));

                InstaMedia firstMedia = instaMediaList?.Value?.FirstOrDefault();

                if (firstMedia != null && firstMedia.MediaType != InstaMediaType.Video && !IsAlreadyPosted(firstMedia.InstaIdentifier, queue.LoginData.Name, db))
                {
                    var caption = GetCaption(queue, firstMedia);
                    isMediaPosted = await PostMediaAsync(firstMedia, caption);
                }

                if (isMediaPosted || group.Equals(allGroups.LastOrDefault()))
                {
                    await UpdateQueueLastActivityAsync(queue, db);
                    await AddFinishedQueuToHistory(firstMedia.InstaIdentifier, queue, db);

                    Console.WriteLine($"PostMediaExecutor for {queue.LoginData.Name}");
                    return;
                }
            }
        }
Пример #4
0
        public async Task <ActionModel> DoComment(InstaMedia media, string comments)
        {
            ActionModel dataAction = new ActionModel
            {
                Type     = "Comment",
                Username = userSession.UserName,
                Status   = 0
            };

            try
            {
                var comment = await HelpersInstaApi.InstaApi.CommentProcessor.CommentMediaAsync(media.Pk, comments);

                if (comment.Succeeded)
                {
                    dataAction.Status   = 1;
                    dataAction.Response = $"[+] {dataAction.Type} | Status: Success | Page: https://instagram.com/p/{media.Code} | Text: {comment.Value.Text}";
                }
                else
                {
                    dataAction.Response = $"[+] {dataAction.Type} | Status: Failed | Error: {comment.Info.Message}";
                }
            }
            catch (Exception ex)
            {
                dataAction.Response = $"[+] {dataAction.Type} | Status: Failed | Error: {ex.Message}";
            }

            return(dataAction);
        }
Пример #5
0
        public static string GetLatestPictureOfUser(string name)
        {
            //IResult<InstaUser> usersearch = await api.GetUserAsync(username);

            string id = "";
            IResult <InstaMediaList> media = _api.UserProcessor.GetUserMediaAsync(name, PaginationParameters.MaxPagesToLoad(1)).Result;

            //System.Threading.Thread.Sleep(1000);
            Console.Write(media.Info);
            if (!media.Succeeded)
            {
                Console.WriteLine(" " + "failed");
            }
            else
            {
                List <InstaMedia> mediaList = media.Value.ToList();

                InstaMedia firstInstaMedia = mediaList.First <InstaMedia>();
                id = firstInstaMedia.InstaIdentifier;
                Console.WriteLine(id);
            }


            return(id);
        }
Пример #6
0
        public async Task <SmartCaption> Enrich(InstaMedia message)
        {
            logger.LogInformation("Generating caption...");
            SmartCaption captionHolder = captionHandler.Extract(message.Caption?.Text);

            logger.LogInformation("Found [{0}] tags in original caption", captionHolder.TotalTags);

            if (captionHolder.TotalTags > 20)
            {
                logger.LogInformation("Found more than 20 tags on photo - ignoring it");
                return(captionHolder);
            }

            var original     = captionHolder.Tags.ToArray();
            var locationTags = await tagsByLocation.Get(message.Location).ConfigureAwait(false);

            foreach (var tag in locationTags.OrderByDescending(item => item.MediaCount).Take(totalLocationTags))
            {
                if (captionHolder.TotalTags >= totalTags)
                {
                    return(captionHolder);
                }

                captionHolder.AddTag(tag);
            }

            var results = await GetMix(original, totalTags - locationTags.Length).ConfigureAwait(false);

            foreach (var data in results)
            {
                captionHolder.AddTag(data);
            }

            return(captionHolder);
        }
Пример #7
0
        public async void SetMedia(string mediaId)
        {
            var media = await Helper.InstaApi.MediaProcessor.GetMediaByIdAsync(mediaId);

            if (media.Succeeded)
            {
                Media = media.Value;
                if (ScrollView == null)
                {
                    //if (NavigationMode == NavigationMode.Back) return;
                    ScrollView = ItemsLV.FindScrollViewer();
                    if (ScrollView != null)
                    {
                        ScrollView.ViewChanging += ScrollViewViewChanging;
                    }
                    CommentsVM.SetLV(ScrollView);
                }
                CommentsVM.ResetCache();
                ToggleGoUpButtonAnimation(false);
                if (Media != null)
                {
                    CommentsVM.SetMedia(Media);
                }
                CommentsVM.RunLoadMore(true);
            }
        }
Пример #8
0
        public static string PrintMedia(string header, InstaMedia media)
        {
            var content = $"{header}: {media.Caption?.Text.Truncate(30)}, {media.Code}";

            content.Output();
            return(content);
        }
Пример #9
0
        public static InstaImageUpload AsUpload(
            this InstaImage image,
            InstaMedia media,
            string uri)
        {
            var imageUpload = new InstaImageUpload(uri, image.Width, image.Height);
            var tagsUpload  = new List <InstaUserTagUpload>();

            if (media.UserTags != null)
            {
                foreach (var tag in media.UserTags)
                {
                    var tagUpload = new InstaUserTagUpload();
                    if (tag.User != null)
                    {
                        tagUpload.Username = tag.User.UserName;
                    }

                    if (tag.Position != null)
                    {
                        tagUpload.X = tag.Position.X;
                        tagUpload.Y = tag.Position.Y;
                    }

                    tagsUpload.Add(tagUpload);
                }
            }
            imageUpload.UserTags.AddRange(tagsUpload);
            return(imageUpload);
        }
Пример #10
0
        public static string PrintMedia(string header, InstaMedia media)
        {
            var content = $"{header}: {media.Caption?.Text.Truncate(30)}, {media.Code}";

            Debug.WriteLine(content);
            return(content);
        }
Пример #11
0
        public async void TotalDePublicacoes(string username, IInstaApi api)
        {
            IResult <InstaUser> userSearch = await api.GetUserAsync(username);

            Console.WriteLine($"USER:{userSearch.Value.FullName}\n\tFollowers: {userSearch.Value.FollowersCount}\n\t {userSearch.Value.IsVerified}");

            IResult <InstaMediaList> media = await api.GetUserMediaAsync(username, PaginationParameters.MaxPagesToLoad(5));

            List <InstaMedia> mediaList = mediaList = media.Value.ToList();

            for (int i = 0; i < mediaList.Count; i++)
            {
                InstaMedia m = mediaList[i];
                if (m != null && m.Caption != null)
                {
                    string captionText = m.Caption.Text;
                    if (captionText != null)
                    {
                        if (m.MediaType == InstaMediaType.Image)
                        {
                            for (int X = 0; X < m.Images.Count; X++)
                            {
                                if (m.Images[X] != null && m.Images[X].URI != null)
                                {
                                    Console.WriteLine($"\n\t{captionText}");
                                    string uri = m.Images[X].URI;

                                    Console.Write($"{uri}\n\t");
                                }
                            }
                        }
                    }
                }
            }
        }
Пример #12
0
        private string GetCaption(Queue queue, InstaMedia instaMedia)
        {
            var caption = "";

            caption = queue.Notes ?? instaMedia.Caption.Text;

            return(caption);
        }
Пример #13
0
 protected override void OnNavigatedTo(NavigationEventArgs e)
 {
     base.OnNavigatedTo(e);
     if (e.Parameter is InstaMedia media)
     {
         Media = media;
     }
 }
Пример #14
0
        async void HandleLinkOrMediaId(string mediaIdOrLink)
        {
            try
            {
                if (string.IsNullOrEmpty(mediaIdOrLink))
                {
                    return;
                }
                mediaIdOrLink = mediaIdOrLink.Trim();
                await MainPage.Current.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, async() =>
                {
                    ShowTopLoading();
                    try
                    {
                        string mediaId = mediaIdOrLink;
                        if (mediaIdOrLink.StartsWith("http://") || mediaIdOrLink.StartsWith("https://") || mediaIdOrLink.StartsWith("www."))
                        {
                            var mediaInfoFromUrl = await Helper.InstaApi.MediaProcessor.GetMediaIdFromUrlAsync(new Uri(mediaIdOrLink));
                            if (mediaInfoFromUrl.Succeeded)
                            {
                                mediaId = mediaInfoFromUrl.Value;
                            }
                            else
                            {
                                if (mediaInfoFromUrl.Info.ResponseType == InstagramApiSharp.Classes.ResponseType.PrivateMedia)
                                {
                                    Helper.ShowNotify("This media is private and can't get view it with URL.", 5000);
                                    HideTopLoading();
                                    Helpers.NavigationService.GoBack();
                                    return;
                                }
                                else if (mediaInfoFromUrl.Info.ResponseType == InstagramApiSharp.Classes.ResponseType.NoMediaMatch)
                                {
                                    Helper.ShowNotify("No media match.\r\nThis means media is deleted or something is wrong with URL you provided.", 5000);
                                    HideTopLoading();
                                    Helpers.NavigationService.GoBack();
                                    return;
                                }
                            }
                        }

                        var media = await Helper.InstaApi.MediaProcessor.GetMediaByIdAsync(mediaId);
                        if (media.Succeeded)
                        {
                            Media = /*ToPost*/ (media.Value);
                        }
                        else
                        {
                            Helper.ShowNotify("Something went wrong!", 4000);
                        }
                    }
                    catch { }
                    HideTopLoading();
                });
            }
            catch { HideTopLoading(); }
        }
Пример #15
0
 public static Media ToMedia(this InstaMedia instaMedia)
 {
     return(new Media
     {
         Id = instaMedia.Pk,
         LikesCount = instaMedia.LikesCount,
         User = instaMedia.User.ToUserInfo()
     });
 }
Пример #16
0
        public static IEnumerable <InstaImage> GetImages(
            this InstaMedia media)
        {
            if (media.Images == null)
            {
                return(new InstaImage[0]);
            }

            return(media.Images.Where(i => i.Width == media.Images.Max(m => m.Width)));
        }
Пример #17
0
        public static IEnumerable <InstaVideo> GetOriginalVideos(
            this InstaMedia media)
        {
            if (media.Videos == null)
            {
                return(new InstaVideo[0]);
            }

            return(media.Videos.Where(i => i.Width == media.Width));
        }
Пример #18
0
        public static bool IsObsoleted(
            this InstaMedia media,
            int threshold)
        {
            if (media == null)
            {
                return(true);
            }

            return((DateTime.UtcNow - media.GetMediaDate()).TotalDays > threshold);
        }
Пример #19
0
        public static string GetInstagramUrl(
            this InstaMedia media)
        {
            if (media == null ||
                string.IsNullOrEmpty(media.Code))
            {
                return(string.Empty);
            }

            return($"{InstagramConst.InstagramMediaUrl}{media.Code}");
        }
Пример #20
0
 internal async void OpenTV(InstaMedia tv)
 {
     try
     {
         await Helper.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
                                          NavigationService.Navigate(typeof(Views.TV.TVPlayer), new object[] { new List <InstaMedia> {
                                                                                                                   tv
                                                                                                               }, 0 }));
     }
     catch { }
 }
Пример #21
0
 public void ResetEverything()
 {
     Media               = null;
     UsernameText.Text   = "";
     DateText.Text       = "";
     TitleText.Text      = "";
     ViewCountRun.Text   = "";
     ViewCountRun.Text   = "";
     ProfileEllipse.Fill = null;
     SetLike(false);
 }
Пример #22
0
 public void SetMedia(InstaMedia media)
 {
     Media = media;
     SetMedia(media.InstaIdentifier);
     //try
     //{
     //    if (media?.Caption != null)
     //        Items.Add(media.Caption?.ToComment());
     //}
     //catch { }
 }
Пример #23
0
 public void ResetCache()
 {
     User          = null;
     CurrentMedia  = null;
     SelectedIndex = -1;
     PageCount     = 1;
     Pagination    = PaginationParameters.MaxPagesToLoad(1);
     IsLoading     = true;
     HasMoreItems  = true;
     Items.Clear();
     FirstRun = true;
 }
Пример #24
0
        private async Task <bool> PostMediaAsync(InstaMedia media, string caption)
        {
            MediaPost mediaPost = GetMediaPost(media);

            InstaImage[] instaImages = LoadImagesAsync(mediaPost.URICollection);

            bool postResult = await UploadPostAsync(instaImages, caption);

            //TODO delete all loaded images

            return(postResult);
        }
Пример #25
0
        public static DateTime GetMediaDate(
            this InstaMedia media)
        {
            if (media.Caption == null ||
                media.Caption.CreatedAtUtc == DateTime.MinValue ||
                media.Caption.CreatedAtUtc == DateTime.UnixEpoch)
            {
                return(media.DeviceTimeStamp);
            }

            return(media.Caption.CreatedAtUtc);
        }
Пример #26
0
        private async void BestNextPK(InstaLikersList value)
        {
            List <IResult <InstaUser> > PKList = new List <IResult <InstaUser> >();

            if (value.Count >= 10)
            {
                for (int i = 0; i < 10; i++)
                {
                    try
                    {
                        IResult <InstaUser> X = await UserWorkation.InstaApi.UserProcessor.GetUserAsync(value[i].UserName);

                        PKList.Add(X);
                    }
                    catch (Exception ex)
                    {
                        Debug.WriteLine("okListErroe: " + ex);
                    }
                }
            }
            else if (value.Count > 0)
            {
                for (int i = 0; i < value.Count; i++)
                {
                    IResult <InstaUser> X = await UserWorkation.InstaApi.UserProcessor.GetUserAsync(value[i].UserName);

                    PKList.Add(X);
                }
            }
            else
            {
                PKList = null;
            }

            //Remove user without post & chise a last post with many like!
            List <IResult <InstaUser> > CleanList = new List <IResult <InstaUser> >();
            var ListOrdered = PKList.OrderBy(o => o.Value.FollowersCount);
            PaginationParameters pagination = PaginationParameters.MaxPagesToLoad(1);

            foreach (var u in ListOrdered)
            {
                var Posts = await UserWorkation.InstaApi.UserProcessor.GetUserMediaAsync(u.Value.UserName, pagination);

                foreach (var p in Posts.Value)
                {
                    if (p.LikesCount > 10)
                    {
                        Best = p;
                    }
                }
            }
        }
Пример #27
0
 public void SetMedia(InstaMedia media)
 {
     Media = media;
     SetMedia(media.InstaIdentifier);
     try
     {
         if (media?.Caption != null)
         {
             Items.Add(media.Caption?.ToComment());
         }
     }
     catch { }
 }
Пример #28
0
 public GenerateCommentItems(InstaMedia instaMedia, ListView listView)
 {
     Media  = instaMedia;
     Items  = new ObservableCollection <InstaComment>();
     LV     = listView;
     Scroll = listView.FindScrollViewer();
     if (Scroll != null)
     {
         Scroll.ViewChanging += Scroll_ViewChanging;
     }
     HasMoreItems = true;
     Pagination   = PaginationParameters.MaxPagesToLoad(1);
 }
Пример #29
0
        public void SetMedia(InstaMedia instaMedia)
        {
            Media = instaMedia;
            if (instaMedia == null)
            {
                ResetEverything();
                return;
            }

            var content = string.Empty;

            if (instaMedia.ViewCount > 0)
            {
                content = $"{instaMedia.ViewCount.Divide()}";
            }
            if (instaMedia.LikesCount > 0)
            {
                var likes = $"{instaMedia.LikesCount.Divide()}";
                //if (!string.IsNullOrEmpty(content))

                //content = likes;
                //else
                //    content += $" | {likes}";
            }

            if (!string.IsNullOrEmpty(instaMedia.CommentsCount))
            {
                var c = int.Parse(instaMedia.CommentsCount);
                if (c > 0)
                {
                    var comments = $"{c.Divide()}";
                    CommentsCountRun.Text = $"{comments}";
                }
            }

            Liked = instaMedia.HasLiked;
            SetLike(instaMedia.HasLiked);
            ViewCountRun.Text   = content;
            DateText.Text       = instaMedia.TakenAt.ToString("MMMM dd", CultureInfo.InvariantCulture);
            UsernameText.Text   = instaMedia.User.UserName;
            TitleText.Text      = instaMedia.Title;
            ProfileEllipse.Fill = new ImageBrush {
                ImageSource = new BitmapImage(new Uri(instaMedia.User.ProfilePicture))
            };
            try
            {
                CanShowControls = true;
                PanelFadeinStory.Begin();
            }
            catch { }
        }
Пример #30
0
        public async Task WriteContent(InstaMedia media)
        {
            string fileName;
            var    width      = 0;
            var    height     = 0;
            var    displayUrl = "";

            switch (media.MediaType)
            {
            case InstaMediaType.Image:
                fileName   = media.Pk + InputValidation.GetUriExtension(media.Images[0].URI);
                width      = media.Images[0].Width;
                height     = media.Images[0].Height;
                displayUrl = media.Images[0].URI;
                break;

            case InstaMediaType.Video:
                fileName   = media.Pk + InputValidation.GetUriExtension(media.Videos[0].Url);
                width      = media.Videos[0].Width;
                height     = media.Videos[0].Height;
                displayUrl = media.Videos[0].Url;
                break;

            case InstaMediaType.Carousel:
                fileName = "Carousel";
                break;

            default:
                throw new ArgumentOutOfRangeException();
            }

            var csvData = new CsvData
            {
                FileName   = $"{fileName}",
                ShortCode  = media.Code,
                DisplaySrc = displayUrl,
                MediaId    = media.Pk,
                Dimensions = $"W: {width} H: {height}",
                Caption    = media.Caption?.Text,
                Likes      = media.LikesCount.ToString(),
                Comments   = media.CommentsCount,
                IsVideo    = media.HasAudio,
                VideoViews = media.ViewCount.ToString(),
                Date       = media.TakenAt.ToLocalTime()
            };

            _csvWriter.WriteRecord(csvData);
            await _csvWriter.NextRecordAsync();
        }