public async Async.Task <PlannerPlan> CreatePlan(Group owner)
{
PlannerPlan forCreate = new PlannerPlan();
forCreate.Title = "Test Plan" + Guid.NewGuid();
forCreate.Owner = owner.Id;
return(await graphClient.Planner.Plans.Request().AddAsync(forCreate));
}
private async Task <PlannerPlan> CreatePlan(string groupId, string channelName)
{
var plannerPlan = new PlannerPlan()
{
Owner = groupId,
Title = channelName
};
return(await GraphClient.Planner.Plans.Request().AddAsync(plannerPlan));
}
private async Task LoadAllTasksAsync()
{
try
{
GraphServiceClient graphClient = await GraphServiceHelper.GetGraphServiceClientAsync();
if (graphClient != null)
{
IPlannerPlanTasksCollectionPage tasks = await graphClient.Planner.Plans[PlanId].Tasks.Request().GetAsync();
Dictionary <string, string> buckets = Buckets.ToDictionary(s => s.Id, s => s.Name);
List <PlannerTaskViewModel> taskList = new List <PlannerTaskViewModel>();
PlannerPlan plan = Plans.FirstOrDefault(s => s.Id == InternalPlanId);
while (true)
{
foreach (PlannerTask task in tasks)
{
PlannerTaskViewModel taskViewModel = new PlannerTaskViewModel(task);
if (plan != null)
{
taskViewModel.GroupId = plan.Owner;
}
taskViewModel.PropertyChanged += TaskViewModel_PropertyChanged;
await GetAssignmentsAsync(taskViewModel, graphClient);
if (!string.IsNullOrEmpty(taskViewModel.BucketId) && buckets.ContainsKey(taskViewModel.BucketId))
{
taskViewModel.BucketName = buckets[taskViewModel.BucketId];
}
taskList.Add(taskViewModel);
}
if (tasks.NextPageRequest == null)
{
break;
}
tasks = await tasks.NextPageRequest.GetAsync();
}
_allTasks.Clear();
_allTasks.AddRange(taskList);
LoadTasks();
}
}
catch (Exception exception)
{
MessageDialog messageDialog = new MessageDialog(exception.Message);
await messageDialog.ShowAsync();
}
}
private async void Add_Click(object sender, RoutedEventArgs e)
{
try
{
GraphServiceClient graphClient = await GraphServiceHelper.GetGraphServiceClientAsync();
if (graphClient != null &&
!string.IsNullOrWhiteSpace(_input?.Text))
{
PlannerTask task = new PlannerTask
{
Title = _input.Text
};
if (TaskType != TaskTypeAllTasksId && TaskType != TaskTypeClosedTasksId)
{
task.BucketId = TaskType;
}
task.PlanId = PlanId;
_input.Text = string.Empty;
CanAddTask = false;
PlannerTask taskCreated = await graphClient.Planner.Tasks.Request().AddAsync(task);
PlannerPlan plan = Plans.FirstOrDefault(s => s.Id == InternalPlanId);
PlannerTaskViewModel taskViewModel = new PlannerTaskViewModel(taskCreated);
Dictionary <string, string> buckets = Buckets.ToDictionary(s => s.Id, s => s.Name);
if (plan != null)
{
taskViewModel.GroupId = plan.Owner;
}
if (!string.IsNullOrEmpty(taskViewModel.BucketId) && buckets.ContainsKey(taskViewModel.BucketId))
{
taskViewModel.BucketName = buckets[taskViewModel.BucketId];
}
if (taskCreated.PlanId == InternalPlanId)
{
taskViewModel.PropertyChanged += TaskViewModel_PropertyChanged;
_allTasks.Add(taskViewModel);
Tasks.Insert(0, taskViewModel);
}
}
}
catch (Exception exception)
{
MessageDialog messageDialog = new MessageDialog(exception.Message);
await messageDialog.ShowAsync();
}
CanAddTask = true;
}
private void UpdateCategories(PlannerPlan plan)
{
SelectedCategory = null;
CustomCategoryGroups.Clear();
var categoryDescriptions = _graphClient.Planner.Plans[plan.Id].Details.Request().GetAsync().Result.CategoryDescriptions;
System.Reflection.PropertyInfo[] propertyInfos = categoryDescriptions.GetType().GetProperties();
foreach (System.Reflection.PropertyInfo propertyInfo in propertyInfos)
{
if (propertyInfo.PropertyType == typeof(string))
{
string value = (string)propertyInfo.GetValue(categoryDescriptions);
CustomCategoryGroups.Add(new CustomCategory(propertyInfo.Name, value, true));
}
}
}
public static async Task <PlannerPlan> AddPlan(string teamId, string title)
{
try
{
var plan = new PlannerPlan();
plan.Owner = teamId;
plan.Title = title;
var results = await graphClient.Groups[teamId].Planner.Plans.Request()
.AddAsync(plan);
return(results);
}
catch (Exception ex)
{
Console.WriteLine($"Error add plan: {ex.Message}");
return(null);
}
}
/// <summary>
/// Update the navigation property plans in users
/// <param name="body"></param>
/// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
/// </summary>
public RequestInformation CreatePatchRequestInformation(PlannerPlan body, Action <PlannerPlanItemRequestBuilderPatchRequestConfiguration> requestConfiguration = default)
{
_ = body ?? throw new ArgumentNullException(nameof(body));
var requestInfo = new RequestInformation {
HttpMethod = Method.PATCH,
UrlTemplate = UrlTemplate,
PathParameters = PathParameters,
};
requestInfo.SetContentFromParsable(RequestAdapter, "application/json", body);
if (requestConfiguration != null)
{
var requestConfig = new PlannerPlanItemRequestBuilderPatchRequestConfiguration();
requestConfiguration.Invoke(requestConfig);
requestInfo.AddRequestOptions(requestConfig.Options);
requestInfo.AddHeaders(requestConfig.Headers);
}
return(requestInfo);
}
/// <summary>
/// Use this API to create a new plannerPlan.
/// </summary>
/// <param name="groupId">The group's ID (team) to create the plannerPlan into.</param>
/// <returns>If successful, this method returns 201 Created response code and plannerPlan object in the response body. In case of errors, see HTTP status codes.</returns>
public async Task CreatePlannerPlan(string groupId)
{
// C# 8.0 Preview 2 feature.
using var cs = this.GetCodeSection();
if (string.IsNullOrWhiteSpace(groupId))
{
cs.Warning(Constants.MESSAGE_WARNING_NULLARGUMENTS);
return;
}
var plannerPlan = new PlannerPlan()
{
Id = groupId
};
var plannerPlanContent = JsonConvert.SerializeObject(plannerPlan);
try
{
HttpResponseMessage httpResponseMessage = null;
var retry = new RetryWithExponentialBackoff <HttpResponseMessage>();
await retry.RunAsync(
async() =>
{
httpResponseMessage = await HttpClient.PostAsync(O365Settings.MsGraphBetaEndpoint + "/planner/plans",
new StringContent(plannerPlanContent, Encoding.UTF8, "application/json"));
return(httpResponseMessage);
});
if (!httpResponseMessage.IsSuccessStatusCode)
{
var ex = new HttpRequestException(Constants.EXCEPTION_HTTPREQUEST + $" Status Code: {httpResponseMessage.StatusCode}.");
cs.Exception(ex);
throw ex;
}
}
catch (Exception ex)
{
cs.Exception(ex);
throw;
}
}
private async Task CreatePlanSDK(MyPlan myPlan, string groupId)
{
try
{
var graphServiceClient = await GetGraphServiceAsync();
var planToCreate = new PlannerPlan
{
Title = myPlan.title,
Owner = groupId
};
//reqPlan.Owner = myPlan.owner;
await graphServiceClient.Planner.Plans.Request().AddAsync(planToCreate);
}
catch (Exception el)
{
el.ToString();
}
}
public async Task UpdatePlanSDK(MyPlan myPlan)
{
try
{
var graphServiceClient = await GetGraphServiceAsync();
var reqPlan = await graphServiceClient.Planner.Plans[myPlan.id].Request().GetAsync();
string etag = reqPlan.GetEtag();
var plan = new PlannerPlan
{
Title = myPlan.title
};
//reqPlan.Owner = myPlan.owner;
await graphServiceClient.Planner.Plans[reqPlan.Id].Request().Header("If-Match", etag).Header("Prefer", "return=representation").UpdateAsync(plan);
}
catch (Exception el)
{
el.ToString();
}
}
public static async Task <TeamsTab> AddPlannerTab(string teamId, string channelId, string title)
{
PlannerPlan plan = null;
TeamsTab newTab = null;
try
{
plan = new PlannerPlan();
plan.Owner = teamId;
plan.Title = title;
plan = await graphClient.Planner.Plans.Request()
.AddAsync(plan);
}
catch (ServiceException ex)
{
Console.WriteLine($"Error add plan: {ex.Message}");
plan = null;
}
if (plan != null)
{
TeamsPlannerTab plannerTab = new TeamsPlannerTab(title, plan.Id);
newTab = await graphClient.Teams[teamId].Channels[channelId].Tabs.Request().AddAsync(plannerTab);
//using (HttpClient httpClient = new HttpClient())
//{
// TeamsPlannerTab plannerTab = new TeamsPlannerTab("Plan Gamma2", plan.Id);
// var resp = await httpClient.PostAsJson(
// $"https://graph.microsoft.com/beta/teams/{teamId}/channels/{channelId}/tabs",
// plannerTab,
// graphClient.AuthenticationProvider as IAuthenticationProvider2);
// newTab = await resp.Content.ReadAsJsonAsync<TeamsTab>();
//}
}
return(newTab);
}
private static async Task <PlannerTask> CreatePlanner(GraphServiceClient graphClient, string groupId, Conversation conversation, User me)
{
string taskTitle = $"{DateTime.Now.ToString("yyyyMMddHHmmss")}-{conversation.Topic}";
PlannerPlan plan = await GetPlannerPlanAsync(graphClient, groupId, "visitor intake");
string bucketId = await GetBucketIdAsync(graphClient, plan, "LobbyIntake");
var newTask = new PlannerTask()
{
PlanId = plan.Id,
ConversationThreadId = conversation.Id,
BucketId = bucketId,
Title = taskTitle
};
newTask.Assignments = new PlannerAssignments();
newTask.Assignments.AddAssignee(me.Id); //Assign the current logged in user
var createdTask = await graphClient.Planner.Tasks.Request().AddAsync(newTask);
return(createdTask);
}
private static async Task <string> GetBucketIdAsync(GraphServiceClient graphClient, PlannerPlan plan, string bucketName)
{
//Note: Buckets does not support $filter, so need to use linq
var planBuckets = await graphClient.Planner
.Plans[plan.Id]
.Buckets
.Request()
.GetAsync();
return(planBuckets.FirstOrDefault(bucket => bucket.Name == bucketName).Id);
}
public static async Task <PlannerPlan> UpdatePlanAsync(HttpClient httpClient, string accessToken, PlannerPlan plan, string title)
{
var stringContent = new StringContent(JsonSerializer.Serialize(new { title }));
stringContent.Headers.ContentType = new System.Net.Http.Headers.MediaTypeHeaderValue("application/json");
var responseMessage = await GraphHelper.PatchAsync(httpClient, accessToken, stringContent, $"v1.0/planner/plans/{plan.Id}", new Dictionary <string, string>() { { "IF-MATCH", plan.ETag } });
while (responseMessage.StatusCode == System.Net.HttpStatusCode.PreconditionFailed)
{
// retrieve the plan again
plan = await GraphHelper.GetAsync <PlannerPlan>(httpClient, $"v1.0/planner/plans/{plan.Id}", accessToken);
responseMessage = await GraphHelper.PatchAsync(httpClient, accessToken, stringContent, $"v1.0/planner/plans/{plan.Id}", new Dictionary <string, string>() { { "IF-MATCH", plan.ETag } });
}
if (responseMessage.IsSuccessStatusCode)
{
var responseContent = await responseMessage.Content.ReadAsStringAsync();
return(JsonSerializer.Deserialize <PlannerPlan>(responseContent));
}
return(null);
}
public PlannerPlanPipeBind(PlannerPlan plan)
{
_plan = plan;
}
private void UpdateBuckets(PlannerPlan plan)
{
SelectedBucket = null;
PlannerBuckets = _graphClient.Planner.Plans[plan.Id].Buckets.Request().GetAsync().Result.ToList();
var categoryDescriptions = _graphClient.Planner.Plans[plan.Id].Details.Request().GetAsync().Result.CategoryDescriptions;
}
public static PlannerPlans FromModel(PlannerPlan model)
{
var vm = Mapper.Map <PlannerPlan, PlannerPlans>(model);
return(vm);
}
public async Task <PlannerPlan> CreatePlanAsync(PlannerPlan plan)
{
return(await graphClient.Planner.Plans.Request().AddAsync(plan));
}
