public static ItemViewModel FromId(
int itemId,
ILoggingService logging,
SQLiteConnection database,
IOfflineTaskService offlineTaskService,
INavigationService navigation,
IPlatformSpecific platform)
{
logging.WriteLine($"Creating ItemViewModel from item id: {itemId}");
var item = database.Find <Item>(itemId);
if (item == null)
{
logging.WriteLine($"Failed! Item does not exist in database!", LoggingCategory.Critical);
}
if (item != null)
{
return(new ItemViewModel(item, offlineTaskService, navigation, logging, platform, database));
}
else
{
return(null);
}
}
public ItemPageViewModel(
IOfflineTaskService offlineTaskService,
ILoggingService loggingService,
IPlatformSpecific device,
INavigationService navigationService,
IWallabagClient client,
SQLite.Net.SQLiteConnection database)
{
_offlineTaskService = offlineTaskService;
_loggingService = loggingService;
_device = device;
_navigationService = navigationService;
_client = client;
_database = database;
_loggingService.WriteLine($"Initializing new instance of {nameof(ItemPageViewModel)}.");
ChangeReadStatusCommand = new RelayCommand(() => ChangeReadStatus());
ChangeFavoriteStatusCommand = new RelayCommand(() => ChangeFavoriteStatus());
EditTagsCommand = new RelayCommand(() => _navigationService.Navigate(Navigation.Pages.EditTagsPage, Item.Model.Id));
DeleteCommand = new RelayCommand(() =>
{
_loggingService.WriteLine("Deleting the current item.");
Item.DeleteCommand.Execute();
_navigationService.GoBack();
});
SaveRightClickLinkCommand = new RelayCommand(() => _offlineTaskService.AddAsync(RightClickUri.ToString(), new List <string>()));
OpenRightClickLinkInBrowserCommand = new RelayCommand(() => _device.LaunchUri(RightClickUri));
CopyLinkToClipboardCommand = new RelayCommand(() => _device.SetClipboardUri(RightClickUri));
}
public AddItemViewModel(IOfflineTaskService offlineTaskService, ILoggingService loggingService, SQLiteConnection database, INavigationService navigationService)
{
_offlineTaskService = offlineTaskService;
_loggingService = loggingService;
_database = database;
_navigationService = navigationService;
TagViewModel = new EditTagsViewModel(offlineTaskService, loggingService, database, navigationService);
NotifyTaskCompletion.Create(() => TagViewModel.ActivateAsync(null, null, NavigationMode.New));
AddCommand = new RelayCommand(() => AddingTask = NotifyTaskCompletion.Create(AddAsync));
CancelCommand = new RelayCommand(() => Cancel());
}
public EditTagsViewModel(IOfflineTaskService offlineTaskService, ILoggingService loggingService, SQLite.Net.SQLiteConnection database, INavigationService navigation)
{
_offlineTaskService = offlineTaskService;
_loggingService = loggingService;
_database = database;
_navigationService = navigation;
_loggingService.WriteLine("Creating new instance of EditTagsViewModel.");
FinishCommand = new RelayCommand(async() => await FinishAsync());
CancelCommand = new RelayCommand(() => Cancel());
TagQueryChangedCommand = new RelayCommand(() =>
{
_loggingService.WriteLine($"Tag query changed: {TagQuery}");
UpdateSuggestions();
});
TagSubmittedCommand = new RelayCommand <Tag>(suggestion =>
{
_loggingService.WriteLine($"Tag was submitted.");
if (suggestion != null && !Tags.Contains(suggestion))
{
_loggingService.WriteLine("Tag wasn't in list yet. Added.");
Tags.Add(suggestion);
UpdateSuggestions();
}
else if (!string.IsNullOrEmpty(TagQuery))
{
var tags = TagQuery.Split(',').ToList();
_loggingService.WriteLine($"Adding {tags.Count} tags to the list.");
foreach (string item in tags)
{
if (!string.IsNullOrWhiteSpace(item))
{
var existingTag = _database.FindWithQuery <Tag>("select * from Tag where Label=?", item);
Tag newTag = null;
if (existingTag != null)
{
newTag = existingTag;
}
else
{
newTag = new Tag()
{
Label = item, Id = Tags.Count + 1
}
};
if (Tags.Contains(newTag) == false)
{
Tags.Add(newTag);
}
}
}
}
TagQuery = string.Empty;
RaisePropertyChanged(nameof(TagsCountIsZero));
});
}
public ItemViewModel(Item item,
IOfflineTaskService offlineTaskService,
INavigationService navigation,
ILoggingService logging,
IPlatformSpecific device,
SQLiteConnection database)
{
Model = item;
_offlineTaskService = offlineTaskService;
_navigationService = navigation;
_loggingService = logging;
_device = device;
_database = database;
(item as INotifyPropertyChanged).PropertyChanged += (s, e) =>
{
_loggingService.WriteLine($"Model with ID {item.Id} was updated.");
RaisePropertyChanged(nameof(item));
};
MarkAsReadCommand = new RelayCommand(async() =>
{
_loggingService.WriteLine($"Marking item {item.Id} as read.");
item.IsRead = true;
UpdateItem();
await _offlineTaskService.AddAsync(item.Id, OfflineTask.OfflineTaskAction.MarkAsRead);
});
UnmarkAsReadCommand = new RelayCommand(async() =>
{
_loggingService.WriteLine($"Marking item {item.Id} as unread.");
item.IsRead = false;
UpdateItem();
await _offlineTaskService.AddAsync(item.Id, OfflineTask.OfflineTaskAction.UnmarkAsRead);
});
MarkAsStarredCommand = new RelayCommand(async() =>
{
_loggingService.WriteLine($"Marking item {item.Id} as favorite.");
item.IsStarred = true;
UpdateItem();
await _offlineTaskService.AddAsync(item.Id, OfflineTask.OfflineTaskAction.MarkAsStarred);
});
UnmarkAsStarredCommand = new RelayCommand(async() =>
{
_loggingService.WriteLine($"Marking item {item.Id} as unfavorite.");
item.IsStarred = false;
UpdateItem();
await _offlineTaskService.AddAsync(item.Id, OfflineTask.OfflineTaskAction.UnmarkAsStarred);
});
DeleteCommand = new RelayCommand(async() =>
{
_loggingService.WriteLine($"Deleting item {item.Id}.");
_database.Delete(item);
await _offlineTaskService.AddAsync(item.Id, OfflineTask.OfflineTaskAction.Delete);
});
ShareCommand = new RelayCommand(() =>
{
_loggingService.WriteLine($"Sharing item {item.Id}.");
_device.ShareItem(item);
});
EditTagsCommand = new RelayCommand(() =>
{
_loggingService.WriteLine($"Editing tags of item {item.Id}.");
_navigationService.Navigate(Pages.EditTagsPage, Model.Id);
});
OpenInBrowserCommand = new RelayCommand(() =>
{
_loggingService.WriteLine($"Opening item {item.Id} in browser.");
_device.LaunchUri(new Uri(item.Url));
});
}
public MultipleSelectionViewModel(
ILoggingService logging,
IOfflineTaskService offlineTaskService,
INavigationService navigationService,
SQLiteConnection database)
{
_loggingService = logging;
_offlineTaskService = offlineTaskService;
_navigationService = navigationService;
_database = database;
_loggingService.WriteLine("Creating new instance of MultipleSelectionViewModel.");
Items = new List <ItemViewModel>();
MarkAsReadCommand = new RelayCommand(() => ExecuteMultipleSelectionAction(() =>
{
_loggingService.WriteLine($"Marking {Items.Count} items as read...");
_database.RunInTransaction(() =>
{
foreach (var item in Items)
{
item.MarkAsReadCommand.Execute();
}
});
}));
UnmarkAsReadCommand = new RelayCommand(() => ExecuteMultipleSelectionAction(() =>
{
_loggingService.WriteLine($"Marking {Items.Count} items as unread...");
_database.RunInTransaction(() =>
{
foreach (var item in Items)
{
item.UnmarkAsReadCommand.Execute();
}
});
}));
MarkAsFavoriteCommand = new RelayCommand(() => ExecuteMultipleSelectionAction(() =>
{
_loggingService.WriteLine($"Marking {Items.Count} items as favorite...");
_database.RunInTransaction(() =>
{
foreach (var item in Items)
{
item.MarkAsStarredCommand.Execute();
}
});
}));
UnmarkAsFavoriteCommand = new RelayCommand(() => ExecuteMultipleSelectionAction(() =>
{
_loggingService.WriteLine($"Marking {Items.Count} items as unfavorited...");
_database.RunInTransaction(() =>
{
foreach (var item in Items)
{
item.UnmarkAsStarredCommand.Execute();
}
});
}));
EditTagsCommand = new RelayCommand(() => ExecuteMultipleSelectionAction(() =>
{
_loggingService.WriteLine($"Editing tags of {Items.Count} items...");
var itemList = new List <Models.Item>();
foreach (var item in Items)
{
itemList.Add(item.Model);
}
_navigationService.Navigate(Navigation.Pages.EditTagsPage, itemList);
}));
OpenInBrowserCommand = new RelayCommand(() => ExecuteMultipleSelectionAction(() =>
{
_loggingService.WriteLine($"Opening {Items.Count} items in the browser...");
foreach (var item in Items)
{
item.OpenInBrowserCommand.Execute();
}
}));
DeleteCommand = new RelayCommand(() => ExecuteMultipleSelectionAction(() =>
{
_loggingService.WriteLine($"Deleting {Items.Count} items...");
_database.RunInTransaction(() =>
{
foreach (var item in Items)
{
item.DeleteCommand.Execute();
}
});
}));
}
