protected override async void Execute(object parameter)
{
var currentMethod = System.Reflection.MethodBase.GetCurrentMethod();
//Microsoft.AppCenter.Analytics.Analytics.TrackEvent($"{currentMethod.DeclaringType.Name}#{currentMethod.Name}");
var data = new Dialogs.MylistGroupEditData()
{
};
var result = await DialogService.ShowCreateMylistGroupDialogAsync(data);
if (result)
{
var mylist = await UserMylistManager.AddMylist(data.Name, data.Description, data.IsPublic, data.DefaultSortKey, data.DefaultSortOrder);
if (mylist == null)
{
return;
}
if (parameter is IVideoContent content)
{
await mylist.AddItem(content);
}
else if (parameter is IEnumerable <IVideoContent> items)
{
await mylist.AddItem(items);
}
}
}
protected override async void Execute(object parameter)
{
var data = new Dialogs.MylistGroupEditData()
{
};
var result = await DialogService.ShowCreateMylistGroupDialogAsync(data);
if (result)
{
var mylistCreateResult = await UserMylistManager.AddMylist(data.Name, data.Description, data.IsPublic, data.MylistDefaultSort, data.IconType);
Debug.WriteLine("マイリスト作成：" + mylistCreateResult);
}
var mylist = UserMylistManager.Mylists.FirstOrDefault(x => x.Label == data.Name);
if (mylist == null)
{
return;
}
if (parameter is Interfaces.IVideoContent content)
{
await mylist.AddItem(content.Id);
}
else if (parameter is string videoId)
{
await mylist.AddItem(videoId);
}
}
public async Task <Tuple <MylistGroupInfo, string> > GetResult()
{
MylistGroupInfo mylistGroupInfo;
if (IsCreateMylistMode.Value)
{
if (HasMylistName.Value == false)
{
throw new Exception();
}
var prevMylistGroups = UserMylistManager.UserMylists.ToArray();
var result = await UserMylistManager.AddMylist(NewMylistName.Value, "", false, Mntone.Nico2.Mylist.MylistDefaultSort.Latest, Mntone.Nico2.Mylist.IconType.Default);
if (result == Mntone.Nico2.ContentManageResult.Success)
{
var added = UserMylistManager.UserMylists.Single(x => !prevMylistGroups.Any(y => x.GroupId == y.GroupId));
mylistGroupInfo = added;
}
else
{
throw new Exception();
}
}
else
{
mylistGroupInfo = SelectedItem.Value;
}
return(new Tuple <MylistGroupInfo, string>(mylistGroupInfo, MylistComment.Value));
}
public DialogService(
UserMylistManager userMylistManager,
LocalMylistManager localMylistManager
)
{
UserMylistManager = userMylistManager;
LocalMylistManager = localMylistManager;
}
public CreateMylistCommand(
UserMylistManager userMylistManager,
DialogService dialogService
)
{
UserMylistManager = userMylistManager;
DialogService = dialogService;
}
public UserInfoPageViewModel(
UserProvider userProvider,
NGSettings ngSettings,
Models.NiconicoSession niconicoSession,
SubscriptionManager subscriptionManager,
UserMylistManager userMylistManager,
Services.HohoemaPlaylist hohoemaPlaylist,
PageManager pageManager,
ExternalAccessService externalAccessService,
NiconicoFollowToggleButtonService followToggleButtonService,
Commands.Subscriptions.CreateSubscriptionGroupCommand createSubscriptionGroupCommand
)
: base(pageManager)
{
HasOwnerVideo = true;
MylistGroups = new ObservableCollection <MylistGroupListItem>();
VideoInfoItems = new ObservableCollection <VideoInfoControlViewModel>();
OpenUserVideoPageCommand = VideoInfoItems.ObserveProperty(x => x.Count)
.Select(x => x > 0)
.ToReactiveCommand()
.AddTo(_CompositeDisposable);
OpenUserVideoPageCommand.Subscribe(x =>
{
PageManager.OpenPage(HohoemaPageType.UserVideo, UserId);
})
.AddTo(_CompositeDisposable);
IsNGVideoOwner = new ReactiveProperty <bool>(false, ReactivePropertyMode.DistinctUntilChanged);
IsNGVideoOwner.Subscribe(isNgVideoOwner =>
{
if (isNgVideoOwner)
{
NgSettings.AddNGVideoOwnerId(UserId, UserName);
IsNGVideoOwner.Value = true;
Debug.WriteLine(UserName + "をNG動画投稿者として登録しました。");
}
else
{
NgSettings.RemoveNGVideoOwnerId(UserId);
IsNGVideoOwner.Value = false;
Debug.WriteLine(UserName + "をNG動画投稿者の指定を解除しました。");
}
});
NiconicoSession = niconicoSession;
SubscriptionManager = subscriptionManager;
UserMylistManager = userMylistManager;
ExternalAccessService = externalAccessService;
FollowToggleButtonService = followToggleButtonService;
CreateSubscriptionGroupCommand = createSubscriptionGroupCommand;
UserProvider = userProvider;
NgSettings = ngSettings;
}
public MylistRepository(
Models.NiconicoSession niconicoSession,
UserMylistManager userMylistManager,
OtherOwneredMylistManager otherOwneredMylistManager
)
{
_niconicoSession = niconicoSession;
_userMylistManager = userMylistManager;
_otherOwneredMylistManager = otherOwneredMylistManager;
}
public PlaylistSelectDialogService(
DialogService dialogService,
UserMylistManager userMylistManager,
LocalMylistManager localMylistManager
)
{
_dialogService = dialogService;
_userMylistManager = userMylistManager;
_localMylistManager = localMylistManager;
}
public AddMylistCommand(
NotificationService notificationService,
UseCase.Playlist.PlaylistSelectDialogService playlistSelectDialogService,
LocalMylistManager localMylistManager,
UserMylistManager userMylistManager
)
{
NotificationService = notificationService;
_playlistSelectDialogService = playlistSelectDialogService;
_localMylistManager = localMylistManager;
_userMylistManager = userMylistManager;
}
public MultiSelectSubscriptionDestinationCommand(
DialogService dialogService,
LocalMylistManager localMylistManager,
UserMylistManager userMylistManager,
Services.HohoemaPlaylist hohoemaPlaylist,
MylistHelper mylistHelper
)
{
DialogService = dialogService;
LocalMylistManager = localMylistManager;
UserMylistManager = userMylistManager;
HohoemaPlaylist = hohoemaPlaylist;
MylistHelper = mylistHelper;
}
public MultiSelectSubscriptionDestinationCommand(
DialogService dialogService,
LocalMylistManager localMylistManager,
UserMylistManager userMylistManager,
HohoemaPlaylist hohoemaPlaylist,
PlaylistAggregateGetter playlistAggregateGetter
)
{
DialogService = dialogService;
LocalMylistManager = localMylistManager;
UserMylistManager = userMylistManager;
HohoemaPlaylist = hohoemaPlaylist;
_playlistAggregateGetter = playlistAggregateGetter;
}
public Interfaces.IMylist FindMylistInCached(string id, Services.PlaylistOrigin?origin = null)
{
if (!origin.HasValue)
{
if (UserMylistManager.HasMylistGroup(id))
{
origin = Services.PlaylistOrigin.LoginUser;
}
else if (Services.HohoemaPlaylist.WatchAfterPlaylistId == id)
{
origin = Services.PlaylistOrigin.Local;
}
else if (LocalMylistManager.Mylists.FirstOrDefault(x => x.Id == id) != null)
{
origin = Services.PlaylistOrigin.Local;
}
else
{
origin = Services.PlaylistOrigin.OtherUser;
}
}
switch (origin.Value)
{
case Services.PlaylistOrigin.LoginUser:
// ログインユーザーのマイリスト
return(UserMylistManager.GetMylistGroup(id));
case Services.PlaylistOrigin.Local:
// ローカルマイリスト
if (Services.HohoemaPlaylist.WatchAfterPlaylistId == id)
{
return(HohoemaPlaylist.DefaultPlaylist);
}
else
{
return(LocalMylistManager.Mylists.FirstOrDefault(x => x.Id == id));
}
case Services.PlaylistOrigin.OtherUser:
// 他ユーザーのマイリスト
return(OtherOwneredMylistManager.GetMylistIfCached(id));
default:
throw new Exception("not found mylist:" + id);
}
}
public MylistVideoInfoContentViewModel(string videoId, string threadId, UserMylistManager mylistManager)
: base()
{
VideoId = videoId;
ThreadId = threadId;
MylistManager = mylistManager;
MylistComment = new ReactiveProperty <string>("")
.AddTo(_CompositeDisposable);
MylistGroups = MylistManager.UserMylists
.Select(x => new VideoTargetedMylistGroupInfoViewModel(videoId, x, this))
.ToList();
DeflistRegistrationCapacity = MylistManager.DeflistRegistrationCapacity;
MylistRegistrationCapacity = MylistManager.MylistRegistrationCapacity;
DeflistRegistrationCount = MylistManager.DeflistRegistrationCount;
MylistRegistrationCount = MylistManager.MylistRegistrationCount;
}
public VideoInfomationPageViewModel(
ApplicationLayoutManager applicationLayoutManager,
AppearanceSettings appearanceSettings,
NGSettings ngSettings,
Models.NiconicoSession niconicoSession,
UserMylistManager userMylistManager,
HohoemaPlaylist hohoemaPlaylist,
NicoVideoProvider nicoVideoProvider,
LoginUserMylistProvider loginUserMylistProvider,
VideoCacheManager videoCacheManager,
SubscriptionManager subscriptionManager,
Models.NicoVideoSessionProvider nicoVideo,
Services.PageManager pageManager,
Services.NotificationService notificationService,
Services.DialogService dialogService,
Services.ExternalAccessService externalAccessService,
AddMylistCommand addMylistCommand,
Commands.Subscriptions.CreateSubscriptionGroupCommand createSubscriptionGroupCommand
)
{
ApplicationLayoutManager = applicationLayoutManager;
_appearanceSettings = appearanceSettings;
NgSettings = ngSettings;
NiconicoSession = niconicoSession;
UserMylistManager = userMylistManager;
HohoemaPlaylist = hohoemaPlaylist;
NicoVideoProvider = nicoVideoProvider;
LoginUserMylistProvider = loginUserMylistProvider;
VideoCacheManager = videoCacheManager;
SubscriptionManager = subscriptionManager;
NicoVideo = nicoVideo;
PageManager = pageManager;
NotificationService = notificationService;
DialogService = dialogService;
ExternalAccessService = externalAccessService;
AddMylistCommand = addMylistCommand;
CreateSubscriptionGroupCommand = createSubscriptionGroupCommand;
NowLoading = new ReactiveProperty <bool>(false);
IsLoadFailed = new ReactiveProperty <bool>(false);
}
public VideoInfomationPageViewModel(
NGSettings ngSettings,
Models.NiconicoSession niconicoSession,
UserMylistManager userMylistManager,
Services.HohoemaPlaylist hohoemaPlaylist,
NicoVideoProvider nicoVideoProvider,
LoginUserMylistProvider loginUserMylistProvider,
VideoCacheManager videoCacheManager,
Models.NicoVideoStreamingSessionProvider nicoVideo,
Services.Helpers.MylistHelper mylistHelper,
Services.PageManager pageManager,
Services.NotificationService notificationService,
Services.DialogService dialogService,
Services.ExternalAccessService externalAccessService,
Commands.AddMylistCommand addMylistCommand,
Commands.Subscriptions.CreateSubscriptionGroupCommand createSubscriptionGroupCommand
)
: base(pageManager)
{
NgSettings = ngSettings;
NiconicoSession = niconicoSession;
UserMylistManager = userMylistManager;
HohoemaPlaylist = hohoemaPlaylist;
NicoVideoProvider = nicoVideoProvider;
LoginUserMylistProvider = loginUserMylistProvider;
VideoCacheManager = videoCacheManager;
NicoVideo = nicoVideo;
MylistHelper = mylistHelper;
NotificationService = notificationService;
DialogService = dialogService;
ExternalAccessService = externalAccessService;
AddMylistCommand = addMylistCommand;
CreateSubscriptionGroupCommand = createSubscriptionGroupCommand;
NowLoading = new ReactiveProperty <bool>(false);
IsLoadFailed = new ReactiveProperty <bool>(false);
}
private async Task Reset()
{
if (Mylist.Value == null)
{
return;
}
CanEditMylist = false;
var mylistOrigin = Mylist.Value?.ToMylistOrigin();
IsLoginUserDeflist = false;
IsWatchAfterLocalMylist = Mylist.Value is Interfaces.ILocalMylist &&
Mylist.Value?.Id == HohoemaPlaylist.WatchAfterPlaylistId;
IsUserOwnerdMylist = Mylist.Value is Interfaces.IUserOwnedMylist;
IsLocalMylist = Mylist.Value is Interfaces.ILocalMylist;
IsLoginUserMylistWithoutDeflist = false;
MaxItemsCount = Mylist.Value.ItemCount;
RaisePropertyChanged(nameof(MaxItemsCount));
switch (mylistOrigin)
{
case PlaylistOrigin.LoginUser:
{
var mylistGroup = UserMylistManager.GetMylistGroup(Mylist.Value.Id);
MylistItems = mylistGroup.ToReadOnlyReactiveCollection(x => new MylistVideItemViewModel(x, mylistGroup))
.AddTo(_NavigatingCompositeDisposable);
MylistTitle = mylistGroup.Label;
MylistDescription = mylistGroup.Description;
ThemeColor = mylistGroup.IconType.ToColor();
IsPublic = mylistGroup.IsPublic;
IsLoginUserDeflist = mylistGroup.IsDeflist;
OwnerUserId = mylistGroup.UserId;
UserName = NiconicoSession.UserName;
CanEditMylist = !IsLoginUserDeflist;
if (IsLoginUserDeflist)
{
MylistState = "とりあえずマイリスト";
DeflistRegistrationCapacity = UserMylistManager.DeflistRegistrationCapacity;
DeflistRegistrationCount = UserMylistManager.DeflistRegistrationCount;
}
else
{
IsLoginUserMylistWithoutDeflist = true;
MylistState = IsPublic ? "公開マイリスト" : "非公開マイリスト";
MylistRegistrationCapacity = UserMylistManager.MylistRegistrationCapacity;
MylistRegistrationCount = UserMylistManager.MylistRegistrationCount;
}
}
break;
case PlaylistOrigin.OtherUser:
var otherOwnedMylist = Mylist.Value as OtherOwneredMylist;
MylistItems = new IncrementalLoadingCollection <OtherOwnedMylistIncrementalSource, MylistVideItemViewModel>(new OtherOwnedMylistIncrementalSource(otherOwnedMylist, MylistProvider, NgSettings));
var response = await MylistProvider.GetMylistGroupDetail(Mylist.Value.Id);
var mylistGroupDetail = response.MylistGroup;
MylistTitle = otherOwnedMylist.Label;
MylistDescription = otherOwnedMylist.Description;
IsPublic = true;
//ThemeColor = mylistGroupDetail.GetIconType().ToColor();
OwnerUserId = mylistGroupDetail.UserId;
MylistState = IsPublic ? "公開マイリスト" : "非公開マイリスト";
var user = Database.NicoVideoOwnerDb.Get(OwnerUserId);
if (user != null)
{
UserName = user.ScreenName;
}
else
{
var userDetail = await UserProvider.GetUser(OwnerUserId);
UserName = userDetail.ScreenName;
}
CanEditMylist = false;
break;
case PlaylistOrigin.Local:
{
var localMylist = Mylist.Value as LocalMylistGroup;
MylistItems = localMylist.ToReadOnlyReactiveCollection(x => new MylistVideItemViewModel(x, localMylist))
.AddTo(_NavigatingCompositeDisposable);
MylistTitle = Mylist.Value.Label;
OwnerUserId = NiconicoSession.UserId.ToString();
UserName = NiconicoSession.UserName;
MylistState = "ローカル";
CanEditMylist = !IsWatchAfterLocalMylist;
}
break;
default:
break;
}
RaisePropertyChanged(nameof(MylistItems));
EditMylistGroupCommand.RaiseCanExecuteChanged();
DeleteMylistCommand.RaiseCanExecuteChanged();
}
public MylistPageViewModel(
Services.PageManager pageManager,
NiconicoSession niconicoSession,
MylistProvider mylistProvider,
UserProvider userProvider,
FollowManager followManager,
LoginUserMylistProvider loginUserMylistProvider,
NGSettings ngSettings,
UserMylistManager userMylistManager,
LocalMylistManager localMylistManager,
Services.HohoemaPlaylist hohoemaPlaylist,
SubscriptionManager subscriptionManager,
Services.DialogService dialogService,
NiconicoFollowToggleButtonService followToggleButtonService,
Services.Helpers.MylistHelper mylistHelper,
Commands.Subscriptions.CreateSubscriptionGroupCommand createSubscriptionGroupCommand
)
: base(pageManager)
{
NiconicoSession = niconicoSession;
MylistProvider = mylistProvider;
UserProvider = userProvider;
FollowManager = followManager;
LoginUserMylistProvider = loginUserMylistProvider;
NgSettings = ngSettings;
UserMylistManager = userMylistManager;
LocalMylistManager = localMylistManager;
HohoemaPlaylist = hohoemaPlaylist;
SubscriptionManager = subscriptionManager;
DialogService = dialogService;
FollowToggleButtonService = followToggleButtonService;
MylistHelper = mylistHelper;
CreateSubscriptionGroupCommand = createSubscriptionGroupCommand;
Mylist = new ReactiveProperty <Interfaces.IMylist>();
MylistOrigin = new ReactiveProperty <Services.PlaylistOrigin>();
/*
* IsFavoriteMylist = new ReactiveProperty<bool>(mode: ReactivePropertyMode.DistinctUntilChanged)
* .AddTo(_CompositeDisposable);
* CanChangeFavoriteMylistState = new ReactiveProperty<bool>()
* .AddTo(_CompositeDisposable);
*
*
* IsFavoriteMylist
* .Where(x => PlayableList.Value.Id != null)
* .Subscribe(async x =>
* {
* if (PlayableList.Value.Origin != PlaylistOrigin.OtherUser) { return; }
*
* if (_NowProcessFavorite) { return; }
*
* _NowProcessFavorite = true;
*
* CanChangeFavoriteMylistState.Value = false;
* if (x)
* {
* if (await FavoriteMylist())
* {
* Debug.WriteLine(_MylistTitle + "のマイリストをお気に入り登録しました.");
* }
* else
* {
* // お気に入り登録に失敗した場合は状態を差し戻し
* Debug.WriteLine(_MylistTitle + "のマイリストをお気に入り登録に失敗");
* IsFavoriteMylist.Value = false;
* }
* }
* else
* {
* if (await UnfavoriteMylist())
* {
* Debug.WriteLine(_MylistTitle + "のマイリストをお気に入り解除しました.");
* }
* else
* {
* // お気に入り解除に失敗した場合は状態を差し戻し
* Debug.WriteLine(_MylistTitle + "のマイリストをお気に入り解除に失敗");
* IsFavoriteMylist.Value = true;
* }
* }
*
* CanChangeFavoriteMylistState.Value =
* IsFavoriteMylist.Value == true
|| FollowManager.CanMoreAddFollow(FollowItemType.Mylist);
||
||
|| _NowProcessFavorite = false;
|| })
|| .AddTo(_CompositeDisposable);
||
||
||UnregistrationMylistCommand = SelectedItems.ObserveProperty(x => x.Count)
|| .Where(_ => IsUserOwnerdMylist)
|| .Select(x => x > 0)
|| .ToReactiveCommand(false);
||
||UnregistrationMylistCommand.Subscribe(async _ =>
||{
|| if (PlayableList.Value.Origin == PlaylistOrigin.Local)
|| {
|| var localMylist = PlayableList.Value as LegacyLocalMylist;
|| var items = SelectedItems.ToArray();
||
|| foreach (var item in items)
|| {
|| localMylist.Remove(item.PlaylistItem);
|| IncrementalLoadingItems.Remove(item);
|| }
|| }
|| else if (PlayableList.Value.Origin == PlaylistOrigin.LoginUser)
|| {
|| var mylistGroup = HohoemaApp.UserMylistManager.GetMylistGroup(PlayableList.Value.Id);
||
|| var items = SelectedItems.ToArray();
||
||
|| var action = AsyncInfo.Run<uint>(async (cancelToken, progress) =>
|| {
|| uint progressCount = 0;
|| int successCount = 0;
|| int failedCount = 0;
||
|| Debug.WriteLine($"マイリストに追加解除を開始...");
|| foreach (var video in items)
|| {
|| var unregistrationResult = await mylistGroup.Unregistration(
|| video.RawVideoId
|| , withRefresh: false );
||
|| if (unregistrationResult == ContentManageResult.Success)
|| {
|| successCount++;
|| }
|| else
|| {
|| failedCount++;
|| }
||
|| progressCount++;
|| progress.Report(progressCount);
||
|| Debug.WriteLine($"{video.Label}[{video.RawVideoId}]:{unregistrationResult.ToString()}");
|| }
||
|| // 登録解除結果を得るためリフレッシュ
|| await mylistGroup.Refresh();
||
||
|| // ユーザーに結果を通知
|| var titleText = $"「{mylistGroup.Label}」から {successCount}件 の動画が登録解除されました";
|| var toastService = App.Current.Container.Resolve<NotificationService>();
|| var resultText = $"";
|| if (failedCount > 0)
|| {
|| resultText += $"\n登録解除に失敗した {failedCount}件 は選択されたままです";
|| }
|| toastService.ShowToast(titleText, resultText);
||
|| // 登録解除に失敗したアイテムだけを残すように
|| // マイリストから除外された動画を選択アイテムリストから削除
|| foreach (var item in SelectedItems.ToArray())
|| {
|| if (false == mylistGroup.CheckRegistratedVideoId(item.RawVideoId))
|| {
|| SelectedItems.Remove(item);
|| IncrementalLoadingItems.Remove(item);
|| }
|| }
||
|| Debug.WriteLine($"マイリストに追加解除完了---------------");
|| });
||
|| await PageManager.StartNoUIWork("マイリストに追加解除", items.Length, () => action);
||
|| }
||
||
||});
||
||
*/
}
public MylistRegistrationDialogContext(UserMylistManager mylistManager, int videoCount, string hideMylistGroupId)
{
UserMylistManager = mylistManager;
_CompositeDisposable = new CompositeDisposable();
IsCreateMylistMode = new ReactiveProperty <bool>(false)
.AddTo(_CompositeDisposable);
// 通常マイリストにこれ以上アイテムを追加できない
IsNoMoreMylistRegistration = !mylistManager.CanAddMylistItem;
SelectableItems = mylistManager.UserMylists
.Where(x => hideMylistGroupId != x.GroupId)
.Where(x => x.IsDeflist || !IsNoMoreMylistRegistration)
.ToList();
SelectedItem = new ReactiveProperty <MylistGroupInfo>(SelectableItems.FirstOrDefault())
.AddTo(_CompositeDisposable);
MylistComment = new ReactiveProperty <string>("")
.AddTo(_CompositeDisposable);
IsSelectedItem = SelectedItem
.Select(x => x != null)
.ToReactiveProperty()
.AddTo(_CompositeDisposable);
NewMylistName = new ReactiveProperty <string>("新しいマイリスト")
.AddTo(_CompositeDisposable);
HasMylistName = NewMylistName.Select(x => x.Length > 0)
.ToReactiveProperty()
.AddTo(_CompositeDisposable);
CanCompleteSelection =
Observable.Merge(
IsCreateMylistMode.ToUnit(),
IsSelectedItem.ToUnit(),
HasMylistName.ToUnit()
)
.Select(_ =>
{
if (IsCreateMylistMode.Value)
{
return(HasMylistName.Value);
}
else
{
return(IsSelectedItem.Value);
}
})
.ToReactiveProperty(false)
.AddTo(_CompositeDisposable);
CanAddMylist = UserMylistManager.CanAddMylistGroup;
IsVisibleMylistComment = true;
// とりマが上限に達しているので追加された場合、古いアイテムが削除されます
IsShowDeflistReachLimitGuide = SelectedItem
.Select(x => x != null && x.IsDeflist && mylistManager.IsDeflistCapacityReached)
.ToReactiveProperty();
DeflistRegistrationCapacity = UserMylistManager.DeflistRegistrationCapacity;
DeflistRegistrationCount = UserMylistManager.DeflistRegistrationCount;
MylistRegistrationCapacity = UserMylistManager.MylistRegistrationCapacity;
MylistRegistrationCount = UserMylistManager.MylistRegistrationCount;
}
public UserMylistPageViewModel(
Services.PageManager pageMaanger,
Services.DialogService dialogService,
NiconicoSession niconicoSession,
UserProvider userProvider,
LoginUserMylistProvider loginUserMylistProvider,
OtherOwneredMylistManager otherOwneredMylistManager,
UserMylistManager userMylistManager,
LocalMylistManager localMylistManager,
HohoemaPlaylist hohoemaPlaylist
)
: base(pageMaanger, useDefaultPageTitle: false)
{
DialogService = dialogService;
NiconicoSession = niconicoSession;
UserProvider = userProvider;
LoginUserMylistProvider = loginUserMylistProvider;
OtherOwneredMylistManager = otherOwneredMylistManager;
UserMylistManager = userMylistManager;
LocalMylistManager = localMylistManager;
HohoemaPlaylist = hohoemaPlaylist;
IsLoginUserMylist = new ReactiveProperty <bool>(false);
OpenMylistCommand = new ReactiveCommand <Interfaces.IMylist>();
OpenMylistCommand.Subscribe(listItem =>
{
PageManager.OpenPage(HohoemaPageType.Mylist,
new MylistPagePayload()
{
Id = listItem.Id, Origin = listItem.ToMylistOrigin()
}
.ToParameterString()
);
});
AddMylistGroupCommand = new DelegateCommand(async() =>
{
MylistGroupEditData data = new MylistGroupEditData()
{
Name = "新しいマイリスト",
Description = "",
IsPublic = false,
MylistDefaultSort = MylistDefaultSort.Latest,
IconType = IconType.Default,
};
// 成功するかキャンセルが押されるまで繰り返す
while (true)
{
if (true == await DialogService.ShowCreateMylistGroupDialogAsync(data))
{
var result = await UserMylistManager.AddMylist(
data.Name,
data.Description,
data.IsPublic,
data.MylistDefaultSort,
data.IconType
);
if (result == Mntone.Nico2.ContentManageResult.Success)
{
await ResetList();
break;
}
}
else
{
break;
}
}
}
, () => UserMylistManager.Mylists.Count < UserMylistManager.MaxMylistGroupCountCurrentUser
);
RemoveMylistGroupCommand = new DelegateCommand <Interfaces.IMylist>(async(item) =>
{
var mylistOrigin = item.ToMylistOrigin();
if (mylistOrigin == PlaylistOrigin.Local)
{
if (item.Id == HohoemaPlaylist.WatchAfterPlaylistId)
{
return;
}
}
else if (mylistOrigin == PlaylistOrigin.LoginUser)
{
if (item.Id == "0")
{
return;
}
}
// 確認ダイアログ
var originText = mylistOrigin == PlaylistOrigin.Local ? "ローカルマイリスト" : "マイリスト";
var contentMessage = $"{item.Label} を削除してもよろしいですか？（変更は元に戻せません）";
var dialog = new MessageDialog(contentMessage, $"{originText}削除の確認");
dialog.Commands.Add(new UICommand("削除", async(i) =>
{
if (mylistOrigin == PlaylistOrigin.Local)
{
LocalMylistManager.RemoveCommand.Execute(item as LocalMylistGroup);
}
else if (mylistOrigin == PlaylistOrigin.LoginUser)
{
await UserMylistManager.RemoveMylist(item.Id);
// await UpdateUserMylist();
}
}));
dialog.Commands.Add(new UICommand("キャンセル"));
dialog.CancelCommandIndex = 1;
dialog.DefaultCommandIndex = 1;
await dialog.ShowAsync();
});
EditMylistGroupCommand = new DelegateCommand <Interfaces.IMylist>(async item =>
{
var mylistOrigin = item.ToMylistOrigin();
if (mylistOrigin == PlaylistOrigin.Local)
{
if (item.Id == HohoemaPlaylist.WatchAfterPlaylistId)
{
return;
}
}
else if (mylistOrigin == PlaylistOrigin.LoginUser)
{
if (item.Id == "0")
{
return;
}
}
if (mylistOrigin == PlaylistOrigin.Local)
{
var localMylist = item as LocalMylistGroup;
var resultText = await DialogService.GetTextAsync("プレイリスト名を変更",
localMylist.Label,
localMylist.Label,
(tempName) => !string.IsNullOrWhiteSpace(tempName)
);
if (!string.IsNullOrWhiteSpace(resultText))
{
localMylist.Label = resultText;
}
}
if (mylistOrigin == PlaylistOrigin.LoginUser)
{
var mylistGroupListItem = item as UserOwnedMylist;
var selectedMylistGroupId = mylistGroupListItem.Id;
if (selectedMylistGroupId == null)
{
return;
}
var mylistGroup = UserMylistManager.GetMylistGroup(selectedMylistGroupId);
MylistGroupEditData data = new MylistGroupEditData()
{
Name = mylistGroup.Label,
Description = mylistGroup.Description,
IsPublic = mylistGroup.IsPublic,
MylistDefaultSort = mylistGroup.Sort,
IconType = mylistGroup.IconType,
};
// 成功するかキャンセルが押されるまで繰り返す
while (true)
{
if (true == await DialogService.ShowCreateMylistGroupDialogAsync(data))
{
mylistGroup.Label = data.Name;
mylistGroup.Description = data.Description;
mylistGroup.IsPublic = data.IsPublic;
mylistGroup.Sort = data.MylistDefaultSort;
mylistGroup.IconType = data.IconType;
var result = await LoginUserMylistProvider.UpdateMylist(mylistGroup);
if (result == Mntone.Nico2.ContentManageResult.Success)
{
// TODO: UI上のマイリスト表示を更新する
break;
}
}
else
{
break;
}
}
}
});
PlayAllCommand = new DelegateCommand <Interfaces.IMylist>((mylist) =>
{
if (mylist.ItemCount == 0)
{
return;
}
HohoemaPlaylist.Play(mylist);
});
AddLocalMylistCommand = new DelegateCommand(async() =>
{
var name = await DialogService.GetTextAsync("新しいローカルマイリスト名を入力", "ローカルマイリスト名", "",
(s) =>
{
if (string.IsNullOrWhiteSpace(s))
{
return(false);
}
if (LocalMylistManager.Mylists.Any(x => x.Label == s))
{
return(false);
}
return(true);
});
if (name != null)
{
LocalMylistManager.Mylists.Add(new LocalMylistGroup(Guid.NewGuid().ToString(), name));
}
});
}
public UserMylistPageViewModel(
ApplicationLayoutManager applicationLayoutManager,
Services.PageManager pageManager,
Services.DialogService dialogService,
NiconicoSession niconicoSession,
UserProvider userProvider,
MylistRepository mylistRepository,
UserMylistManager userMylistManager,
LocalMylistManager localMylistManager,
HohoemaPlaylist hohoemaPlaylist,
CreateLocalMylistCommand createLocalMylistCommand
)
{
ApplicationLayoutManager = applicationLayoutManager;
PageManager = pageManager;
DialogService = dialogService;
NiconicoSession = niconicoSession;
UserProvider = userProvider;
_mylistRepository = mylistRepository;
_userMylistManager = userMylistManager;
_localMylistManager = localMylistManager;
CreateLocalMylistCommand = createLocalMylistCommand;
HohoemaPlaylist = hohoemaPlaylist;
IsLoginUserMylist = new ReactiveProperty <bool>(false);
OpenMylistCommand = new ReactiveCommand <IPlaylist>();
OpenMylistCommand.Subscribe(listItem =>
{
PageManager.OpenPage(HohoemaPageType.Mylist, $"id={listItem.Id}");
});
AddMylistGroupCommand = new DelegateCommand(async() =>
{
MylistGroupEditData data = new MylistGroupEditData()
{
Name = "",
Description = "",
IsPublic = false,
MylistDefaultSort = MylistDefaultSort.Latest,
IconType = IconType.Default,
};
// 成功するかキャンセルが押されるまで繰り返す
while (true)
{
if (true == await DialogService.ShowCreateMylistGroupDialogAsync(data))
{
var result = await _userMylistManager.AddMylist(
data.Name,
data.Description,
data.IsPublic,
data.MylistDefaultSort,
data.IconType
);
if (result == Mntone.Nico2.ContentManageResult.Success)
{
await ResetList();
break;
}
}
else
{
break;
}
}
}
, () => _userMylistManager.Mylists.Count < _userMylistManager.MaxMylistGroupCountCurrentUser
);
RemoveMylistGroupCommand = new DelegateCommand <Interfaces.IPlaylist>(async(item) =>
{
{
if (item is LocalPlaylist localPlaylist)
{
if (localPlaylist.IsWatchAfterPlaylist())
{
return;
}
}
else if (item is LoginUserMylistPlaylist loginUserMylist)
{
if (loginUserMylist.IsDefaultMylist())
{
return;
}
}
}
// 確認ダイアログ
var contentMessage = "ConfirmDeleteX_ImpossibleReDo".Translate(item.Label);
var dialog = new MessageDialog(contentMessage, "ConfirmDeleteX".Translate(item.GetOrigin().Translate()));
dialog.Commands.Add(new UICommand("Delete".Translate(), async(i) =>
{
if (item is LocalPlaylist localPlaylist)
{
_localMylistManager.RemovePlaylist(localPlaylist);
}
else if (item is LoginUserMylistPlaylist loginUserMylist)
{
await _userMylistManager.RemoveMylist(item.Id);
}
}));
dialog.Commands.Add(new UICommand("Cancel".Translate()));
dialog.CancelCommandIndex = 1;
dialog.DefaultCommandIndex = 1;
await dialog.ShowAsync();
});
EditMylistGroupCommand = new DelegateCommand <Interfaces.IPlaylist>(async item =>
{
if (item is LocalPlaylist localPlaylist)
{
if (item.Id == HohoemaPlaylist.WatchAfterPlaylistId)
{
return;
}
var resultText = await DialogService.GetTextAsync("RenameLocalPlaylist".Translate(),
localPlaylist.Label,
localPlaylist.Label,
(tempName) => !string.IsNullOrWhiteSpace(tempName)
);
if (!string.IsNullOrWhiteSpace(resultText))
{
localPlaylist.Label = resultText;
}
}
else if (item is LoginUserMylistPlaylist loginUserMylist)
{
if (loginUserMylist.IsDefaultMylist())
{
return;
}
MylistGroupEditData data = new MylistGroupEditData()
{
Name = loginUserMylist.Label,
Description = loginUserMylist.Description,
IsPublic = loginUserMylist.IsPublic,
MylistDefaultSort = loginUserMylist.DefaultSort,
IconType = loginUserMylist.IconType,
};
// 成功するかキャンセルが押されるまで繰り返す
while (true)
{
if (true == await DialogService.ShowCreateMylistGroupDialogAsync(data))
{
var result = await loginUserMylist.UpdateMylist(data);
if (result == Mntone.Nico2.ContentManageResult.Success)
{
loginUserMylist.Label = data.Name;
loginUserMylist.Description = data.Description;
loginUserMylist.IsPublic = data.IsPublic;
loginUserMylist.DefaultSort = data.MylistDefaultSort;
loginUserMylist.IconType = data.IconType;
break;
}
}
else
{
break;
}
}
}
});
}
public VideoPlayerPageViewModel(
IScheduler scheduler,
IEventAggregator eventAggregator,
Models.NiconicoSession niconicoSession,
Models.Subscription.SubscriptionManager subscriptionManager,
NicoVideoProvider nicoVideoProvider,
ChannelProvider channelProvider,
MylistProvider mylistProvider,
PlayerSettings playerSettings,
CacheSettings cacheSettings,
NGSettings ngSettings,
ApplicationLayoutManager applicationLayoutManager,
HohoemaPlaylist hohoemaPlaylist,
LocalMylistManager localMylistManager,
UserMylistManager userMylistManager,
PageManager pageManager,
MediaPlayer mediaPlayer,
NotificationService notificationService,
DialogService dialogService,
ExternalAccessService externalAccessService,
Commands.Subscriptions.CreateSubscriptionGroupCommand createSubscriptionGroupCommand,
Commands.Mylist.CreateLocalMylistCommand createLocalMylistCommand,
Commands.Mylist.CreateMylistCommand createMylistCommand,
UseCase.NicoVideoPlayer.VideoStreamingOriginOrchestrator videoStreamingOriginOrchestrator,
UseCase.VideoPlayer videoPlayer,
UseCase.CommentPlayer commentPlayer,
KeepActiveDisplayWhenPlaying keepActiveDisplayWhenPlaying,
ObservableMediaPlayer observableMediaPlayer,
WindowService windowService,
VideoEndedRecommendation videoEndedRecommendation,
PrimaryViewPlayerManager primaryViewPlayerManager,
TogglePlayerDisplayViewCommand togglePlayerDisplayViewCommand,
ShowPrimaryViewCommand showPrimaryViewCommand,
MediaPlayerSoundVolumeManager soundVolumeManager
)
{
_scheduler = scheduler;
NiconicoSession = niconicoSession;
SubscriptionManager = subscriptionManager;
NicoVideoProvider = nicoVideoProvider;
ChannelProvider = channelProvider;
MylistProvider = mylistProvider;
PlayerSettings = playerSettings;
CacheSettings = cacheSettings;
NgSettings = ngSettings;
ApplicationLayoutManager = applicationLayoutManager;
HohoemaPlaylist = hohoemaPlaylist;
LocalMylistManager = localMylistManager;
UserMylistManager = userMylistManager;
PageManager = pageManager;
_NotificationService = notificationService;
_HohoemaDialogService = dialogService;
ExternalAccessService = externalAccessService;
CreateSubscriptionGroupCommand = createSubscriptionGroupCommand;
CreateLocalMylistCommand = createLocalMylistCommand;
CreateMylistCommand = createMylistCommand;
_videoStreamingOriginOrchestrator = videoStreamingOriginOrchestrator;
VideoPlayer = videoPlayer;
CommentPlayer = commentPlayer;
PrimaryViewPlayerManager = primaryViewPlayerManager;
TogglePlayerDisplayViewCommand = togglePlayerDisplayViewCommand;
ShowPrimaryViewCommand = showPrimaryViewCommand;
SoundVolumeManager = soundVolumeManager;
ObservableMediaPlayer = observableMediaPlayer
.AddTo(_CompositeDisposable);
WindowService = windowService
.AddTo(_CompositeDisposable);
VideoEndedRecommendation = videoEndedRecommendation
.AddTo(_CompositeDisposable);
_keepActiveDisplayWhenPlaying = keepActiveDisplayWhenPlaying
.AddTo(_CompositeDisposable);
MediaPlayer = mediaPlayer;
SeekCommand = new MediaPlayerSeekCommand(MediaPlayer);
SetPlaybackRateCommand = new MediaPlayerSetPlaybackRateCommand(MediaPlayer);
ToggleMuteCommand = new MediaPlayerToggleMuteCommand(MediaPlayer);
VolumeUpCommand = new MediaPlayerVolumeUpCommand(SoundVolumeManager);
VolumeDownCommand = new MediaPlayerVolumeDownCommand(SoundVolumeManager);
}
public MenuNavigatePageBaseViewModel(
IUnityContainer container,
IScheduler scheduler,
INavigationService navigationService,
AppearanceSettings appearanceSettings,
PinSettings pinSettings,
NiconicoSession niconicoSession,
LocalMylistManager localMylistManager,
UserMylistManager userMylistManager,
VideoCacheManager videoCacheManager,
PageManager pageManager,
PlayerViewManager playerViewManager,
Services.NiconicoLoginService niconicoLoginService,
Commands.LogoutFromNiconicoCommand logoutFromNiconicoCommand
)
{
PageManager = pageManager;
PlayerViewManager = playerViewManager;
NiconicoLoginService = niconicoLoginService;
LogoutFromNiconicoCommand = logoutFromNiconicoCommand;
Container = container;
Scheduler = scheduler;
NavigationService = navigationService;
AppearanceSettings = appearanceSettings;
PinSettings = pinSettings;
NiconicoSession = niconicoSession;
LocalMylistManager = localMylistManager;
UserMylistManager = userMylistManager;
VideoCacheManager = videoCacheManager;
NiconicoSession.LogIn += (sender, e) => ResetMenuItems();
NiconicoSession.LogOut += (sender, e) => ResetMenuItems();
CurrentMenuType = new ReactiveProperty <MenuItemBase>();
VideoMenu = App.Current.Container.Resolve <VideoMenuSubPageContent>();
LiveMenu = App.Current.Container.Resolve <LiveMenuSubPageContent>();
// TV Mode
if (Services.Helpers.DeviceTypeHelper.IsXbox)
{
IsTVModeEnable = new ReactiveProperty <bool>(true);
}
else
{
IsTVModeEnable = AppearanceSettings.ObserveProperty(x => x.IsForceTVModeEnable)
.ToReactiveProperty();
}
ServiceLevel = NiconicoSession.ObserveProperty(x => x.ServiceStatus)
.ToReadOnlyReactiveProperty(eventScheduler: Scheduler);
IsNeedFullScreenToggleHelp
= ApplicationView.PreferredLaunchWindowingMode == ApplicationViewWindowingMode.FullScreen;
IsOpenPane = new ReactiveProperty <bool>(false);
MainSelectedItem = new ReactiveProperty <HohoemaListingPageItemBase>(null, ReactivePropertyMode.DistinctUntilChanged);
PinItems = new ObservableCollection <PinItemViewModel>(
PinSettings.Pins.Select(x => Container.Resolve <PinItemViewModel>(new ParameterOverride("pin", x)))
);
bool isPinItemsChanging = false;
PinSettings.Pins.CollectionChangedAsObservable()
.Subscribe(args =>
{
if (isPinItemsChanging)
{
return;
}
if (args.Action == System.Collections.Specialized.NotifyCollectionChangedAction.Add)
{
foreach (var item in args.NewItems)
{
PinItems.Add(Container.Resolve <PinItemViewModel>(new ParameterOverride("pin", item as HohoemaPin)));
}
RaisePropertyChanged(nameof(PinItems));
}
else if (args.Action == System.Collections.Specialized.NotifyCollectionChangedAction.Remove)
{
foreach (var item in args.OldItems)
{
var removedPin = item as HohoemaPin;
var pinVM = PinItems.FirstOrDefault(x => x.Pin == removedPin);
if (pinVM != null)
{
PinItems.Remove(pinVM);
}
}
RaisePropertyChanged(nameof(PinItems));
}
});
ResetMenuItems();
// TODO; PinSettings側で自動保存するようにしたい
PinItems.CollectionChangedAsObservable()
.Subscribe(async _ =>
{
await Task.Delay(50);
try
{
isPinItemsChanging = true;
PinSettings.Pins.Clear();
foreach (var pin in PinItems)
{
PinSettings.Pins.Add(pin.Pin);
}
}
finally
{
isPinItemsChanging = false;
}
});
/*
* Observable.Merge(
* MainSelectedItem,
* SubSelectedItem
* )
* .Where(x => x != null)
* .Subscribe(x => x.SelectedAction(x.Source));
*/
/*
* PageManager.ObserveProperty(x => x.CurrentPageType)
* .Subscribe(pageType =>
* {
* // IsOpenPane.Value = false;
*
* bool isMenuItemOpened = false;
* foreach (var item in MenuItems)
* {
* if ((item as MenuItemViewModel)?.PageType == pageType)
* {
* MainSelectedItem.Value = item;
* isMenuItemOpened = true;
* break;
* }
* }
*
*
* if (!isMenuItemOpened)
* {
* MainSelectedItem.Value = null;
* }
*
* if (Services.Helpers.DeviceTypeHelper.IsXbox || AppearanceSettings.IsForceTVModeEnable
|| Services.Helpers.DeviceTypeHelper.IsMobile
|| )
|| {
|| IsOpenPane.Value = false;
|| }
|| });
*/
PageManager.ObserveProperty(x => x.PageTitle)
.Subscribe(x =>
{
TitleText = x;
});
CanGoBackNavigation = new ReactiveProperty <bool>();
(NavigationService as IPlatformNavigationService).CanGoBackChanged += (_, e) =>
{
CanGoBackNavigation.Value = NavigationService.CanGoBack();
};
/*
* IsVisibleMenu = PageManager.ObserveProperty(x => x.CurrentPageType)
* .Select(x =>
* {
* return !PageManager.IsHiddenMenuPage(x);
* })
* .ToReactiveProperty(false);
*/
NowNavigating = PageManager.ObserveProperty(x => x.PageNavigating)
.ToReactiveProperty();
PageManager.StartWork += PageManager_StartWork;
PageManager.ProgressWork += PageManager_ProgressWork;
PageManager.CompleteWork += PageManager_CompleteWork;
PageManager.CancelWork += PageManager_CancelWork;
UserName = NiconicoSession.ObserveProperty(x => x.UserName)
.ToReadOnlyReactiveProperty(eventScheduler: Scheduler);
UserIconUrl = NiconicoSession.ObserveProperty(x => x.UserIconUrl)
.ToReadOnlyReactiveProperty(eventScheduler: Scheduler);
// 検索
SearchKeyword = new ReactiveProperty <string>("");
SearchCommand = new ReactiveCommand();
SearchCommand
.Subscribe(async _ =>
{
await Task.Delay(50);
var keyword = SearchKeyword.Value;
if (string.IsNullOrWhiteSpace(keyword))
{
return;
}
SearchTarget?searchType = CurrentMenuType.Value is LiveMenuSubPageContent ? SearchTarget.Niconama : SearchTarget.Keyword;
var searched = Database.SearchHistoryDb.LastSearchedTarget(keyword);
if (searched != null)
{
searchType = searched;
}
PageManager.Search(searchType.Value, keyword);
ResetSearchHistoryItems();
});
SearchSuggestionWords = new ObservableCollection <string>();
// InAppNotification
IsShowInAppNotification = new ReactiveProperty <bool>(true);
// 検索履歴アイテムを初期化
ResetSearchHistoryItems();
}
public async Task <Interfaces.IUserOwnedMylist> ChoiceMylist(
params string[] ignoreMylistId
)
{
const string CreateNewContextLabel = @"@create_new";
var mylists = UserMylistManager.Mylists;
var localMylists = LocalMylistManager.Mylists;
List <ISelectableContainer> selectDialogContent;
if (false)
{
selectDialogContent = new List <ISelectableContainer>()
{
new ChoiceFromListSelectableContainer("マイリスト",
mylists.Where(x => ignoreMylistId.All(y => x.Id != y))
.Select(x => new SelectDialogPayload()
{
Label = x.Label, Id = x.Id, Context = x
})
),
new ChoiceFromListSelectableContainer("ローカルマイリスト",
localMylists.Where(x => ignoreMylistId.All(y => x.Id != y))
.Select(x => new SelectDialogPayload()
{
Label = x.Label, Id = x.Id, Context = x
})
),
new ChoiceFromListSelectableContainer("新規作成",
new [] {
new SelectDialogPayload()
{
Label = "マイリストを作成", Id = "mylist", Context = CreateNewContextLabel
},
new SelectDialogPayload()
{
Label = "ローカルマイリストを作成", Id = "local", Context = CreateNewContextLabel
},
}
)
};
}
else
{
selectDialogContent = new List <ISelectableContainer>()
{
new ChoiceFromListSelectableContainer("ローカルマイリスト",
localMylists.Where(x => ignoreMylistId.All(y => x.Id != y))
.Select(x => new SelectDialogPayload()
{
Label = x.Label, Id = x.Id, Context = x
})
),
new ChoiceFromListSelectableContainer("新規作成",
new [] {
new SelectDialogPayload()
{
Label = "ローカルマイリストを作成", Id = "local", Context = CreateNewContextLabel
},
}
)
};
}
Interfaces.IUserOwnedMylist resultList = null;
while (resultList == null)
{
var result = await ShowContentSelectDialogAsync(
"追加先マイリストを選択",
selectDialogContent
);
if (result == null)
{
break;
}
if (result?.Context as string == CreateNewContextLabel)
{
var mylistTypeLabel = result.Id == "mylist" ? "マイリスト" : "ローカルマイリスト";
var title = await GetTextAsync(
$"{mylistTypeLabel}を作成",
$"{mylistTypeLabel}名",
validater : (str) => !string.IsNullOrWhiteSpace(str)
);
if (title == null)
{
continue;
}
if (result.Id == "mylist")
{
await UserMylistManager.AddMylist(title, "", false, Mntone.Nico2.Mylist.MylistDefaultSort.FirstRetrieve_Descending, Mntone.Nico2.Mylist.IconType.Default);
resultList = UserMylistManager.Mylists.FirstOrDefault(x => x.Label == title);
}
else //if (result.Id == "local")
{
var localMylist = new LocalMylistGroup(Guid.NewGuid().ToString(), title);
LocalMylistManager.Mylists.Add(localMylist);
resultList = localMylist;
}
}
else
{
resultList = result?.Context as Interfaces.IUserOwnedMylist;
}
}
return(resultList);
}
