protected override async void Execute(object parameter)
        {
            if (parameter is Models.Subscription.Subscription subscription)
            {
                // 既に登録済みのアイテムを先頭にして
                // 続いてマイリスト、ローカルプレイリストと表示する
                var playlists = new List <Interfaces.IPlaylist>()
                {
                    HohoemaPlaylist.WatchAfterPlaylist
                };

                foreach (var playlist in UserMylistManager.Mylists)
                {
                    playlists.Add(playlist);
                }

                foreach (var playlist in LocalMylistManager.LocalPlaylists)
                {
                    playlists.Add(playlist);
                }

                var selectedItems = new List <Interfaces.IPlaylist>();
                foreach (var dest in subscription.Destinations.Reverse())
                {
                    var list = await _playlistAggregateGetter.FindPlaylistAsync(dest.PlaylistId);

                    if (list != null)
                    {
                        playlists.Remove(list);
                        playlists.Insert(0, list);

                        selectedItems.Add(list);
                    }
                }


                var choiceItems = await DialogService.ShowMultiChoiceDialogAsync(
                    $"SelectSubscriptionGroup".Translate(),
                    playlists,
                    selectedItems,
                    x => x.Label
                    );

                if (choiceItems == null)
                {
                    return;
                }

                subscription.Destinations.Clear();
                foreach (var choiceItem in choiceItems)
                {
                    var dest = new Models.Subscription.SubscriptionDestination(
                        choiceItem.Label,
                        choiceItem.GetOrigin() == PlaylistOrigin.Local ? Models.Subscription.SubscriptionDestinationTarget.LocalPlaylist : Models.Subscription.SubscriptionDestinationTarget.LoginUserMylist,
                        choiceItem.Id
                        );
                    subscription.Destinations.Add(dest);
                }
            }
        }
        public async Task OnNavigatedToAsync(INavigationParameters parameters)
        {
            string id = null;

            if (parameters.TryGetValue<string>("id", out var idString))
            {
                id = idString;
            }
            else if (parameters.TryGetValue<int>("id", out var idInt))
            {
                id = idInt.ToString();
            }

            var playlist = await _playlistAggregate.FindPlaylistAsync(id);

            if (playlist is MylistPlaylist) { return; }
            if (playlist == null) { return; }

            Playlist = playlist;

            RefreshItems();
        }
Beispiel #3
0
        private async void ShowNewVideosToastNotification(Subscription subscription, SubscriptionSource source, IEnumerable <IVideoContent> newItems)
        {
            var mylistMan = App.Current.Container.Resolve <UserMylistManager>();

            // TODO: プレイリスト毎にまとめたほうがいい?

            foreach (var dest in subscription.Destinations)
            {
                Interfaces.IPlaylist list = null;
                list = await _playlistAggregate.FindPlaylistAsync(dest.PlaylistId);

                if (list == null)
                {
                    // TODO: 購読で利用できない追加先プレイリストを通知する
                    continue;
                }

                IList <IVideoContent> videoList;
                if (NewItemsPerPlayableList.TryGetValue(list, out var cacheVideoList))
                {
                    videoList = cacheVideoList.Item1;

                    if (!cacheVideoList.Item2.Contains(subscription))
                    {
                        cacheVideoList.Item2.Add(subscription);
                    }
                }
                else
                {
                    videoList = new List <IVideoContent>();
                    NewItemsPerPlayableList.Add(list, new Tuple <IList <IVideoContent>, IList <Subscription> >(videoList, new List <Subscription>()
                    {
                        subscription
                    }));
                }

                foreach (var video in newItems)
                {
                    videoList.Add(video);
                }
            }


            try
            {
                foreach (var pair in NewItemsPerPlayableList)
                {
                    var playableList    = pair.Key;
                    var newItemsPerList = pair.Value.Item1;
                    var subscriptions   = pair.Value.Item2;

                    ToastVisual visual = new ToastVisual()
                    {
                        BindingGeneric = new ToastBindingGeneric()
                        {
                            Children = { }
                        }
                    };

                    visual.BindingGeneric.Children.Insert(0, new AdaptiveText()
                    {
                        Text      = "InAppNotification_AddItemToSubscription".Translate(playableList.Label),
                        HintStyle = AdaptiveTextStyle.Base
                    });

                    foreach (var item in newItemsPerList)
                    {
                        visual.BindingGeneric.Children.Add(new AdaptiveText()
                        {
                            Text      = item.Label,
                            HintStyle = AdaptiveTextStyle.BaseSubtle
                        });
                    }



                    ToastActionsCustom action = new ToastActionsCustom()
                    {
                        Buttons =
                        {
                            new ToastButton("WatchVideo".Translate(),           new LoginRedirectPayload()
                            {
                                RedirectPageType = HohoemaPageType.VideoPlayer, RedirectParamter           = $"id={newItemsPerList.First().Id}&playlist_id=@view"
                            }.ToParameterString())
                            {
                                ActivationType = ToastActivationType.Foreground,
                            },
                            new ToastButton("SubscriptionSettings".Translate(), new LoginRedirectPayload()
                            {
                                RedirectPageType = HohoemaPageType.Subscription
                            }.ToParameterString())
                            {
                                ActivationType = ToastActivationType.Foreground,
                            },
                        }
                    };

                    ToastContent toastContent = new ToastContent()
                    {
                        Visual  = visual,
                        Actions = action,
                    };

                    var toast = new ToastNotification(toastContent.GetXml());

                    var notifier = ToastNotificationManager.CreateToastNotifier();

                    toast.Tag   = playableList.Id;
                    toast.Group = TOAST_GROUP;
                    notifier.Show(toast);
                }
            }
            catch (Exception ex)
            {
                Debug.WriteLine(ex.ToString());
            }
        }
        /*
         *
         * private async Task<bool> FavoriteMylist()
         *      {
         *              if (PlayableList.Value == null) { return false; }
         *  if (PlayableList.Value.Origin != PlaylistOrigin.OtherUser) { return false; }
         *
         *              var favManager = HohoemaApp.FollowManager;
         *              var result = await favManager.AddFollow(FollowItemType.Mylist, PlayableList.Value.Id, PlayableList.Value.Label);
         *
         *              return result == ContentManageResult.Success || result == ContentManageResult.Exist;
         *      }
         *
         *      private async Task<bool> UnfavoriteMylist()
         *      {
         *              if (PlayableList.Value == null) { return false; }
         *  if (PlayableList.Value.Origin != PlaylistOrigin.OtherUser) { return false; }
         *
         *  var favManager = HohoemaApp.FollowManager;
         *              var result = await favManager.RemoveFollow(FollowItemType.Mylist, PlayableList.Value.Id);
         *
         *              return result == ContentManageResult.Success;
         *
         *      }
         *
         */

        public async Task OnNavigatedToAsync(INavigationParameters parameters)
        {
            string mylistId = null;

            if (parameters.TryGetValue <string>("id", out var idString))
            {
                mylistId = idString;
            }
            else if (parameters.TryGetValue <int>("id", out var idInt))
            {
                mylistId = idInt.ToString();
            }

            var mylist = await _playlistAggregate.FindPlaylistAsync(mylistId) as MylistPlaylist;

            if (mylist == null)
            {
                return;
            }

            Mylist.Value = mylist;

            IsUserOwnerdMylist      = _mylistRepository.IsLoginUserMylistId(mylist.Id);
            IsLoginUserDeflist      = mylist.IsDefaultMylist();
            IsWatchAfterLocalMylist = false;
            IsLocalMylist           = false;

            if (mylist is LoginUserMylistPlaylist loginMylist)
            {
                Observable.FromEventPattern <MylistItemAddedEventArgs>(
                    h => loginMylist.MylistItemAdded += h,
                    h => loginMylist.MylistItemAdded -= h
                    )
                .Subscribe(e =>
                {
                    var args = e.EventArgs;
                    if (args.MylistId == Mylist.Value.Id)
                    {
                        RefreshCommand.Execute();
                    }
                })
                .AddTo(_NavigatingCompositeDisposable);

                Observable.FromEventPattern <MylistItemRemovedEventArgs>(
                    h => loginMylist.MylistItemRemoved += h,
                    h => loginMylist.MylistItemRemoved -= h
                    )
                .Subscribe(e =>
                {
                    var args = e.EventArgs;
                    if (args.MylistId == Mylist.Value.Id)
                    {
                        foreach (var removed in args.SuccessedItems)
                        {
                            var removedItem = MylistItems.FirstOrDefault(x => x.Id == removed);
                            if (removedItem != null)
                            {
                                MylistItems.Remove(removedItem);
                            }
                        }
                    }
                })
                .AddTo(_NavigatingCompositeDisposable);
            }

            MylistItems = await CreateItemsSourceAsync(mylist);

            MaxItemsCount = Mylist.Value.Count;

            if (Mylist.Value != null)
            {
                MylistBookmark = Database.BookmarkDb.Get(Database.BookmarkType.Mylist, Mylist.Value.Id)
                                 ?? new Database.Bookmark()
                {
                    Label        = Mylist.Value.Label,
                    Content      = Mylist.Value.Id,
                    BookmarkType = Database.BookmarkType.Mylist,
                };

                FollowToggleButtonService.SetFollowTarget(Mylist.Value as Interfaces.IFollowable);

                RaisePropertyChanged(nameof(MylistBookmark));
            }

            EditMylistGroupCommand.RaiseCanExecuteChanged();
            DeleteMylistCommand.RaiseCanExecuteChanged();
        }