private async void BtnLogin_OnClick(object sender, EventArgs e)
{
var model = DataContext as LoginViewModel;
if (string.IsNullOrEmpty(model.ApiKey))
{
MessageBox.Show("Set your Asana API key", "Error", MessageBoxButton.OK);
return;
}
btnLogin.IsEnabled = false;
AsanaStateService.SetAuthToken(model.ApiKey);
model.IsBusy = true;
var response = await new AsanaRespository().GetWorkspaces();
btnLogin.IsEnabled = true;
if (AsanaClient.ProcessResponse(response, true))
{
AsanaStateService.SetAuthToken(model.ApiKey);
ExNavigationService.Navigate <MainPage>();
}
else
{
AsanaStateService.SetAuthToken("");
OnError(response);
}
model.IsBusy = false;
}
async void browser_Navigating(object sender, NavigatingEventArgs e)
{
Model.IsBusy = true;
try
{
if (e.Uri.Host.Contains(_website))
{
string[] data = e.Uri.Fragment.Split(new string[] { "&" }, StringSplitOptions.RemoveEmptyEntries);
var token = data[0].Replace("#access_token=", "");
token = HttpUtility.UrlDecode(token);
AsanaStateService.SetAuthToken(token);
var response = await new AsanaRespository().GetUser("me");
if (AsanaClient.ProcessResponse(response))
{
if (response.Data.id != SettingsService.LoggedUserId)
{
await Bootstrapper.Current.Container.Resolve <DbService>().ClearDb();
}
SettingsService.LoggedUserId = response.Data.id;
SettingsService.CurrentUserId = response.Data.id;
ExNavigationService.Navigate <MainPage>();
}
}
}
catch (Exception exc)
{
Debug.WriteLine(exc.Message);
}
}
async void SendSomment()
{
if (String.IsNullOrEmpty(CommentText))
{
return;
}
if (IsBusy)
{
return;
}
IsBusy = true;
ProgressText = "Processing";
var response = await new AsanaRespository().CreateTaskStory(Id, new AsanaStory()
{
text = CommentText
});
if (AsanaClient.ProcessResponse(response))
{
response.Data.userId = response.Data.created_by.id;
response.Data.targetId = Id;
await GetStorageService().Insert(response.Data);
Comments.Insert(0, response.Data);
Container.Resolve <IMessagePublisher>().Publish(new FocusListMessage(this));
CommentText = "";
}
IsBusy = false;
SetDefaultProgressText();
}
protected override async void OnNavigatedTo()
{
//if(AsanaStateService.IsSetApiKey)
//{
// ExNavigationService.Navigate<MainPage>();
// return;
//}
if (AsanaStateService.IsSetAuthToken)
{
if (await NetworkHelper.IsNetworkAvailableViaRequest(3000))
{
var response = await new AsanaApiRepository().GetUser("me");
if (AsanaClient.ProcessResponse(response, true))
{
NavigationService.Navigate <MainPage>();
}
else
{
NavigationService.Navigate <LoginPage>();
}
}
else
{
NavigationService.Navigate <MainPage>();
}
}
else
{
NavigationService.Navigate <LoginPage>();
}
}
async Task AddTag(string name)
{
if (String.IsNullOrEmpty(name))
{
return;
}
var tag = new AsanaTag()
{
name = name
};
IsBusy = true;
var response = await new AsanaRespository().CreateTag(WorkspaceId, tag);
if (AsanaClient.ProcessResponse(response))
{
response.Data.workspaceid = WorkspaceId;
await new StorageService().Insert(response.Data);
Tags.Add(response.Data);
var selectedTags = SelectedTags;
selectedTags.Add(response.Data);
SelectedTags = selectedTags;
}
IsBusy = false;
}
async Task LoadTaskTags(bool isUserAction = false)
{
if (CheckInternetConnection(false))
{
var response = await new AsanaRespository().GetTask(Id);
if (AsanaClient.ProcessResponse(response, !isUserAction, async r =>
{
return(await ProcessNotFoundTask(r));
}))
{
var dbTags = await new StorageService().GetTaskTagsByTask(Id);
if (response.Data.tags != null)
{
foreach (var tag in response.Data.tags)
{
var dbTag = dbTags.FirstOrDefault(x => x.TagId == tag.id);
if (dbTag != null)
{
dbTag.IsFoundInDb = true;
}
else
{
await GetStorageService().Insert(new AsanaTagTask()
{
TagId = tag.id, TaskId = Id, id = Guid.NewGuid().GetHashCode()
});
}
}
}
foreach (var asanaTagTask in dbTags.Where(x => !x.IsFoundInDb))
{
await GetStorageService().Delete(asanaTagTask);
}
DispatcherHelper.OnUi(async() =>
{
await SetTags();
});
}
}
}
async Task LoadUserId()
{
if (SettingsService.LoggedUserId > 0)
{
return;
}
var response = await new AsanaApiRepository().GetUser("me");
if (AsanaClient.ProcessResponse(response, true))
{
SettingsService.LoggedUserId = response.Data.id;
SettingsService.CurrentUserId = response.Data.id;
}
}
protected override async void OnNavigatedTo(NavigationEventArgs e)
{
base.OnNavigatedTo(e);
SmallProfiler.PrintLine("StartPage - OnNavigatedTo");
#if DEBUG
Bootstrapper.Current.Container.Resolve <IApplicationSettingsService>().SetSetting("ApiKey", "2IPsBtr.EBOluTYUi2mwwz86RkWKNHr6");
AsanaStateService.Initialize();
#endif
if (AsanaStateService.IsSetApiKey)
{
ExNavigationService.Navigate <MainPage>();
return;
}
if (AsanaStateService.IsSetAuthToken)
{
if (NetworkHelper.IsNetworkAvailableNew())
{
var response = await new AsanaRespository().GetUser("me");
if (AsanaClient.ProcessResponse(response, true))
{
ExNavigationService.Navigate <MainPage>();
}
else
{
ExNavigationService.Navigate <LoginNewPage>();
}
}
else
{
ExNavigationService.Navigate <MainPage>();
}
}
else
{
ExNavigationService.Navigate <LoginNewPage>();
}
}
async Task RefreshData()
{
if (IsBusy)
{
return;
}
if (!CheckInternetConnection(true))
{
return;
}
IsBusy = true;
var response = await new AsanaRespository().GetTask(Id);
if (AsanaClient.ProcessResponse(response, false, async r =>
{
return(await ProcessNotFoundTask(r));
}))
{
var task = await new StorageService().Find <AsanaTask>(Id);
MapperService.Map(response.Data, task.workspaceid);
await GetStorageService().Save(response.Data);
DispatcherHelper.OnUi(async() =>
{
await SetTaskInfo(response.Data);
});
await LoadStories(false);
await LoadSubtasks(false);
await LoadTaskTags(false);
}
DispatcherHelper.OnUi(() =>
{
IsBusy = false;
});
}
async System.Threading.Tasks.Task LoadStories(bool isUserAction = false)
{
if (CheckInternetConnection(false))
{
AddOperation();
var stories =
await
new AsanaRespository().GetStoriesByTask(Id);
if (AsanaClient.ProcessResponse(stories, !isUserAction))
{
var dbStories = await GetStorageService().GetStories(Id);
foreach (var story in stories.Data)
{
var dbStory =
dbStories.FirstOrDefault(
x => x.id == story.id);
if (dbStory != null)
{
dbStory.IsFoundInDb = true;
}
story.userId = story.created_by.id;
story.targetId = Id;
await GetStorageService().Save(story);
}
foreach (var story in dbStories.Where(x => !x.IsFoundInDb))
{
await GetStorageService().Delete(story);
}
}
await LoadStoriesFromDb();
}
RemoveOperation();
}
/// <summary>
/// Agent that runs a scheduled task
/// </summary>
/// <param name="task">
/// The invoked task
/// </param>
/// <remarks>
/// This method is called when a periodic or resource intensive task is invoked
/// </remarks>
protected override async void OnInvoke(ScheduledTask task)
{
Debug.WriteLine("OnInvoke");
if (!AsanaStateService.IsSetAuthToken && !AsanaStateService.IsSetApiKey)
{
Debug.WriteLine("Complete - no auth");
NotifyComplete();
return;
}
var response = await new AsanaRespository().GetWorkspaces();
if (!AsanaClient.ProcessResponse(response, true))
{
Debug.WriteLine("Complete - no connection");
NotifyComplete();
return;
}
var service = new LoadDataService(false);
service.IsBackgroundAgent = true;
var projects = await new StorageService().GetProjectsForRefresh();
foreach (var project in projects)
{
await service.LoadProjectTasks(project.workspaceid, project.id, false);
}
TileService.UpdateMainTile();
Debug.WriteLine("Complete - OK");
NotifyComplete();
}
public async void AddNewSubTask()
{
if (String.IsNullOrEmpty(NewSubTaskText))
{
return;
}
if (!CheckInternetConnection(true))
{
return;
}
IsBusy = true;
var task = await new StorageService().Find <AsanaTask>(Id);
var dto = MapperService.CreateTaskDTO(0, NewSubTaskText, "", 0, "later", 0, false, null, null);
var response = await new AsanaRespository().CreateTask(task.workspaceid, dto, Id);
if (AsanaClient.ProcessResponse(response))
{
MapperService.Map(response.Data, task.projectid, task.workspaceid);
await new StorageService().Insert(response.Data);
Subtasks.Add(response.Data);
NewSubTaskText = "";
Container.Resolve <IMessagePublisher>().Publish(new FocusListMessage(this)
{
IsSubtasks = true
});
}
IsBusy = false;
}
public async Task UpdateTask(long id, bool isCompleted, DateTime?dueOn, Action <AsanaTask> action)
{
if (IsBusy)
{
return;
}
ProgressText = "Syncing";
IsBusy = true;
var task = await new StorageService().Find <AsanaTask>(id);
if (!dueOn.HasValue)
{
dueOn = task.due_on;
}
var dto = MapperService.CreateTaskDTO(id, task.name, task.notes, task.projectid, task.assignee_status,
task.assigneeid, isCompleted, dueOn, null);
var response = await new AsanaApiRepository().UpdateTask(dto);
if (AsanaClient.ProcessResponse(response))
{
task.due_on = dueOn;
task.completed = isCompleted;
await new StorageService().Save(task);
if (action != null)
{
action(task);
}
}
IsBusy = false;
SetDefaultProgressText();
}
public AsanaOAuthBaseActivity(ICrateManager crateManager, IAsanaParameters parameters, IRestfulServiceClient client) : base(crateManager)
{
// :( i want dependancy injection here ↓
AClient = new AsanaClient(parameters, client);
}
async System.Threading.Tasks.Task ProcessFollowers(AsanaTask task)
{
var currentFollowers = SelectedFollowers.Select(x => x.id).ToList();
var followersToAdd = new List <long>();
var followersToRemove = new List <long>();
foreach (var currentFollower in currentFollowers)
{
if (!OldFollowersIds.Contains(currentFollower))
{
followersToAdd.Add(currentFollower);
}
}
foreach (var oldFollowersId in OldFollowersIds)
{
if (!currentFollowers.Contains(oldFollowersId))
{
followersToRemove.Add(oldFollowersId);
}
}
var success = false;
if (followersToAdd.Any())
{
var response = await new AsanaRespository().AddFollowers(task.id,
followersToAdd);
if (AsanaClient.ProcessResponse(response, true))
{
success = true;
}
else
{
return;
}
}
if (followersToRemove.Any())
{
var response = await new AsanaRespository().RemoveFollowers(task.id,
followersToRemove);
if (AsanaClient.ProcessResponse(response, true))
{
success = true;
}
else
{
return;
}
}
if (success)
{
task.SetFollowers(currentFollowers);
}
task.followers = null;
if (followersToAdd.Any() || followersToRemove.Any())
{
await PrepareAndSaveTaskToDb(task);
}
}
async System.Threading.Tasks.Task ProcessTags(AsanaTask task)
{
var currentTags = SelectedTags.Select(x => x.id).ToList();
var tagsToAdd = new List <long>();
var tagsToRemove = new List <long>();
foreach (var tag in currentTags)
{
if (!OldTagsIds.Contains(tag))
{
tagsToAdd.Add(tag);
}
}
foreach (var tag in OldTagsIds)
{
if (!currentTags.Contains(tag))
{
tagsToRemove.Add(tag);
}
}
var taskTags = await new StorageService().GetTaskTagsByTask(task.id);
var forInsert = new List <AsanaTagTask>();
var forDelete = new List <AsanaTagTask>();
foreach (var l in tagsToAdd)
{
var response = await new AsanaRespository().AddTag(task.id, l);
if (AsanaClient.ProcessResponse(response, true))
{
var link = new AsanaTagTask()
{
TagId = l, TaskId = task.id, id = Guid.NewGuid().GetHashCode()
};
forInsert.Add(link);
}
}
foreach (var l in tagsToRemove)
{
var response = await new AsanaRespository().RemoveTag(task.id, l);
if (AsanaClient.ProcessResponse(response, true))
{
var link = taskTags.FirstOrDefault(x => x.TagId == l);
if (link != null)
{
forDelete.Add(link);
}
}
}
foreach (var asanaTagTask in forInsert)
{
await new StorageService().Insert(asanaTagTask);
}
foreach (var asanaTagTask in forDelete)
{
await new StorageService().Delete(asanaTagTask);
}
}
async void SaveTask()
{
if (IsBusy || IsBlockingProgress)
{
return;
}
if (string.IsNullOrEmpty(Name))
{
MessageBox.Show("Specify name");
return;
}
if (Project == null)
{
MessageBox.Show("Specify project");
return;
}
IsBlockingProgress = true;
DateTime?dueDate = null;
if (IsUseDueDate)
{
dueDate = DueDate;
}
var dto = MapperService.CreateTaskDTO(Id.GetValueOrDefault(0), Name,
Notes,
!IsEditMode ? Project.id : 0,
Status.name,
User != null && User.id > 0 ? User.id : -1,
IsCompleted, dueDate, SelectedFollowers.Select(x => x.id).ToList());
//var task = new AsanaTaskDTO() {
// name = model.Name,
// notes = model.Notes,
// completed = model.IsCompleted,
// id = model.Id.GetValueOrDefault(0),
// assignee = -1,
// assignee_status = model.Status.name };
//if (model.IsUseDueDate)
//{
// task.due_on = model.DueDate.ToString("yyyy-MM-dd");
//}
//else
//{
// task.due_on = "null";
//}
//if (!model.IsEditMode)
//{
// task.projects = model.Project.id;
//}
//if (model.User != null && model.User.id > 0)
//{
// task.assignee = model.User.id;
//}
//save task for syncing later
if (!CheckInternetConnection(false))
{
if (IsForSync || !IsEditMode)
{
AsanaTask dbTask;
if (IsEditMode)
{
dbTask = Task;
}
else
{
dbTask = new AsanaTask()
{
id = await new StorageService().GetLocalTaskId(),
workspaceid = Project.workspaceid,
modified_at = DateTime.Now,
created_at = DateTime.Now,
IsForSync = true
};
}
dbTask.name = dto.name;
dbTask.notes = dto.notes;
dbTask.completed = dto.completed;
dbTask.assignee_status = dto.assignee_status;
dbTask.assigneeid = dto.assignee == AsanaConstants.Utils.NULL_VALUE ? -1 : long.Parse(dto.assignee);
dbTask.projectid = Project.id;
dbTask.parentId = ParentId;
dbTask.SetFollowers(dto.followers.Select(X => X.id).ToList());
if (IsUseDueDate)
{
dbTask.due_on = DueDate;
}
else
{
dbTask.due_on = null;
}
await new StorageService().Save(dbTask);
if (!IsEditMode)
{
MessageBox.Show("Task saved for syncing when network will be available");
}
IsBlockingProgress = false;
NavigationManager.GoBack();
return;
}
}
if (IsForSync && IsEditMode)
{
var task = await new StorageService().Find <AsanaTask>(Id.Value);
await CheckSyncStatus(task);
IsForSync = false;
IsBlockingProgress = false;
return;
}
//normal save
var response = !IsEditMode ? await new AsanaRespository().CreateTask(WorkspaceId, dto, ParentId) : await new AsanaRespository().UpdateTask(dto);
if (AsanaClient.ProcessResponse(response))
{
if (IsEditMode && OldProjectId != Project.id)
{
var newResponse = await new AsanaRespository().ChangeTaskProject(Id.Value, OldProjectId, Project.id);
if (AsanaClient.ProcessResponse(newResponse))
{
await PrepareAndSaveTaskToDb(response.Data);
await ProcessFollowers(response.Data);
await ProcessTags(response.Data);
}
}
else
{
await PrepareAndSaveTaskToDb(response.Data);
if (IsEditMode)
{
await ProcessFollowers(response.Data);
}
await ProcessTags(response.Data);
}
NavigationManager.GoBack();
return;
}
IsBlockingProgress = false;
}
