public async IAsyncEnumerable <DriveItem> GetChildrenAsync(IAccount account, string parentId)
{
BeforeTaskExecuted?.Invoke(this, null);
var userId = GetUserId(account);
using var cts = new CancellationTokenSource(Timeouts.Silent);
var request = graphClient.Users[userId].Drive.Items[parentId].Children.Request();
do
{
IDriveItemChildrenCollectionPage page;
try {
page = await request.GetAsync(cts.Token).ConfigureAwait(false);
} catch (TaskCanceledException ex) {
logger?.LogError(ex, "Use canncel the task.");
TaskExecuted?.Invoke(this, null);
yield break;
} catch (ServiceException ex) {
logger?.LogError(ex, "onedrive server error.");
TaskExecuted?.Invoke(this, null);
yield break;
}
foreach (var file in page)
{
yield return(file);
}
request = page?.NextPageRequest;
} while (request != null);
TaskExecuted?.Invoke(this, null);
}
/// <summary>
/// This method can only be used with <see cref="Authority.Organizations"/>
/// Only used in test.
/// </summary>
public async Task <AuthenticationResult> LoginWithUsernamePassword(string username = null, string password = null)
{
this.username = username ?? this.username;
this.password = password ?? this.password;
if (this.username == null || this.password == null)
{
return(null);
}
BeforeTaskExecuted?.Invoke(this, null);
using var cts = new CancellationTokenSource(Timeouts.Silent);
var secureString = new SecureString();
foreach (var c in this.password ?? "")
{
secureString.AppendChar(c);
}
var result = await msalClient
.AcquireTokenByUsernamePassword(scopes, this.username, secureString)
.ExecuteAsync(cts.Token).ConfigureAwait(false);
var account = result?.Account;
RegisterUser(account);
TaskExecuted?.Invoke(this, null);
return(result);
}
/// <summary>
///
/// </summary>
/// <param name="taskExecuter"></param>
/// <returns></returns>
private bool InternalExecuteTask(TaskExecuter taskExecuter)
{
var result = taskExecuter.Execute();
TaskExecuted?.Invoke(taskExecuter);
return(result);
}
/// <summary>
/// 通知工作线程执行任务完成。
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
/// <exception cref="ObjectDisposedException"></exception>
protected void OnTaskExecuted(object sender, TaskExecutedEventArgs <TTask> e)
{
if (disposed)
{
throw new ObjectDisposedException(nameof(BackgroundTaskThreadService <TTask, TThread>));
}
DecrementWorkThread();
TaskExecuted?.Invoke(sender, e);
}
public async Task <Stream> GetFileContentAsync(IAccount account, string fileId)
{
BeforeTaskExecuted?.Invoke(this, null);
var userId = GetUserId(account);
var cts = new CancellationTokenSource(Timeouts.Silent);
try {
return(await graphClient.Users[userId].Drive.Items[fileId].Content.Request().GetAsync(cts.Token).ConfigureAwait(false));
} catch (ServiceException ex) {
logger?.LogError(ex, "onedrive server error");
return(null);
} finally {
TaskExecuted?.Invoke(this, null);
}
}
public async Task <bool> LogoutAsync(IAccount account)
{
BeforeTaskExecuted?.Invoke(this, null);
try {
// TODO: this method just clears the cache without truely logout the user!!
await msalClient.RemoveAsync(account).ConfigureAwait(false);
accountList.Remove(account);
return(true);
} catch (Exception ex) {
logger?.LogError(ex, "");
return(false);
} finally {
TaskExecuted?.Invoke(this, null);
}
}
public async Task <User> GetUserAsync(IAccount account)
{
BeforeTaskExecuted?.Invoke(this, null);
var userId = GetUserId(account);
using var cts = new CancellationTokenSource(Timeouts.Silent);
try {
var user = await graphClient.Users[userId].Request().GetAsync(cts.Token).ConfigureAwait(false);
return(user);
} catch (ServiceException ex) {
logger?.LogError(ex, "onedrive server error");
return(null);
} finally {
TaskExecuted?.Invoke(this, null);
}
}
public async Task <AuthenticationResult> LoginInteractively(CancellationToken token)
{
BeforeTaskExecuted?.Invoke(this, null);
var requestBuilder = msalClient.AcquireTokenInteractive(scopes);
try {
var result = await requestBuilder
.ExecuteAsync(token)
.ConfigureAwait(false);
RegisterUser(result?.Account);
return(result);
} catch (MsalClientException) {
logger?.LogInformation("User cancelled.");
} catch (MsalException ex) {
logger?.LogWarning(ex, "Masl exception.");
} catch (InvalidOperationException ex) {
logger?.LogError(ex, "");
}
TaskExecuted?.Invoke(this, null);
return(null);
}
public async IAsyncEnumerable <AuthenticationResult> LoginAllUserSilently()
{
BeforeTaskExecuted?.Invoke(this, null);
var accounts = await msalClient.GetAccountsAsync().ConfigureAwait(false);
foreach (var account in accounts)
{
AuthenticationResult result;
try {
using var cts = new CancellationTokenSource(Timeouts.Silent);
result = await msalClient.AcquireTokenSilent(scopes, account)
.ExecuteAsync(cts.Token)
.ConfigureAwait(false);
RegisterUser(result?.Account);
} catch (Exception ex) {
logger?.LogError(ex, "onedrive server error");
continue;
}
yield return(result);
}
TaskExecuted?.Invoke(this, null);
}
public async Task <bool> ExecuteAsync(OfflineTask task)
{
_loggingService.WriteLine($"Executing task {task.Id} with action {task.Action} for item {task.ItemId}.");
int placeholderId = -1;
if (_platform.InternetConnectionIsAvailable == false)
{
_loggingService.WriteLine("No internet connection available. Cancelled.");
TaskExecuted?.Invoke(this, new OfflineTaskExecutedEventArgs(task, -1, false));
return(false);
}
bool executionIsSuccessful = false;
switch (task.Action)
{
case OfflineTaskAction.MarkAsRead:
executionIsSuccessful = await _client.ArchiveAsync(task.ItemId);
break;
case OfflineTaskAction.UnmarkAsRead:
executionIsSuccessful = await _client.UnarchiveAsync(task.ItemId);
break;
case OfflineTaskAction.MarkAsStarred:
executionIsSuccessful = await _client.FavoriteAsync(task.ItemId);
break;
case OfflineTaskAction.UnmarkAsStarred:
executionIsSuccessful = await _client.UnfavoriteAsync(task.ItemId);
break;
case OfflineTaskAction.EditTags:
var item = _database.Find <Item>(i => i.Id == task.ItemId);
if (item == null)
{
/* This can happen in several cases even if it shouldn't.
* In the case the item is already deleted, the task will be marked as success so it's removed asap. */
executionIsSuccessful = true;
break;
}
if (task.AddedTags?.Count > 0)
{
var newTags = await _client.AddTagsAsync(task.ItemId, task.AddedTags.ToStringArray());
if (newTags != null)
{
var convertedTags = new ObservableCollection <Tag>();
foreach (var tag in newTags)
{
convertedTags.Add(tag);
}
_database.InsertOrReplaceAll(convertedTags);
item.Tags.Replace(convertedTags);
}
}
if (task.RemovedTags?.Count > 0)
{
var tagsToRemove = new List <WallabagTag>();
foreach (var tag in task.RemovedTags)
{
tagsToRemove.Add(tag);
}
if (await _client.RemoveTagsAsync(task.ItemId, tagsToRemove))
{
foreach (var tag in task.RemovedTags)
{
if (item.Tags.Contains(tag))
{
item.Tags.Remove(tag);
}
}
}
}
executionIsSuccessful = _database.Update(item) == 1;
break;
case OfflineTaskAction.AddItem:
placeholderId = _database.FindWithQuery <Item>("select Id from Item where Content=?", m_PLACEHOLDER_PREFIX + task.Id)?.Id ?? -1;
if (placeholderId >= 0)
{
_database.Delete <Item>(placeholderId);
}
var newItem = await _client.AddAsync(new Uri(task.Url), task.Tags);
if (newItem != null)
{
_database.InsertOrReplace((Item)newItem);
task.ItemId = newItem.Id;
}
executionIsSuccessful = newItem != null;
break;
case OfflineTaskAction.Delete:
executionIsSuccessful = await _client.DeleteAsync(task.ItemId);
break;
default:
break;
}
if (executionIsSuccessful)
{
_loggingService.WriteLine($"Execution of task {task.Id} was successful.");
_database.Delete(task);
}
_loggingService.WriteLineIf(!executionIsSuccessful, "Execution was not successful.", LoggingCategory.Warning);
TaskExecuted?.Invoke(this, new OfflineTaskExecutedEventArgs(task, placeholderId, executionIsSuccessful));
return(executionIsSuccessful);
}
/// <summary>
/// 通知工作线程执行任务完成。
/// </summary>
/// <param name="e"></param>
protected virtual void OnTaskExecuted(TaskExecutedEventArgs <TTask> e)
{
TaskExecuted?.Invoke(this, e);
}
private async Task Next(CancellationToken cancellationToken)
{
if (cancellationToken.IsCancellationRequested)
{
return;
}
if (!_isBusy)
{
if (queue.Count > 0)
{
// Optional delay.
if (Delay > default(TimeSpan))
{
await Task.Delay(Delay);
}
// Peek the current task.
var context = queue.Peek();
try
{
_isRunning = true;
_isBusy = true;
// Execute the current task.
TaskExecuting?.Invoke(this, new TaskEventArgs(context.Tag));
await context.Action(context, cts.Token);
}
catch (Exception exc)
{
// Handle any exception thrown inside a task.
// Invoke the Exception event handlers.
TaskException?.Invoke(this, new TaskEventArgs(context.Tag, exc));
if (CancelOnException)
{
// Cancel the queue.
ClearInternal();
}
}
TaskExecuted?.Invoke(this, new TaskEventArgs(context.Tag));
// Dequeue the currently finished task and request the next.
if (queue.Count > 0)
{
queue.Dequeue();
}
_isBusy = false;
await Next(cts.Token);
}
}
else
{
_isRunning = false;
}
}
