private string GetAlignedToMetricFromDetails(PlannerTaskDetails details)
{
return(Regex.Match(
details.Description,
"(?<=Aligned to Metric\r\n).*",
RegexOptions.Compiled | RegexOptions.Multiline).Value);
}
public static async Task <PlannerTaskDetails> AddPlannerTaskDetails(PlannerTaskDetails plannerTaskDetails, string taskId, string clientId = null)
{
var graphClient = GetAuthenticatedClient();
if (!string.IsNullOrEmpty(clientId))
{
var hubContext = GlobalHost.ConnectionManager.GetHubContext <MwHub>();
hubContext.Clients.Client(clientId).addMessage("GET: " + graphClient.Planner.Tasks[taskId].Details.Request().RequestUrl);
}
var originalTaskDescription = await graphClient
.Planner
.Tasks[taskId]
.Details
.Request()
.GetAsync();
if (!string.IsNullOrEmpty(clientId))
{
var hubContext = GlobalHost.ConnectionManager.GetHubContext <MwHub>();
hubContext.Clients.Client(clientId).addMessage("PATCH: " + graphClient.Planner.Tasks[taskId].Details.Request().RequestUrl);
}
var response = await graphClient
.Planner
.Tasks[taskId]
.Details
.Request()
.Header("If-Match", originalTaskDescription.GetEtag())
.UpdateAsync(plannerTaskDetails);
return(response);
}
private string GetNextStepsFromDetails(PlannerTaskDetails details)
{
return(Regex.Match(
details.Description,
"(?<=Next Steps(\r\n)+).*(?=(\r\n)+Aligned to Metric)",
RegexOptions.Compiled | RegexOptions.Multiline).Value);
}
public async Task <PlannerTask> CreateAsync(string planId, string title, DateTimeOffset?startDate, string ownerId, string description)
{
var newIdearBucket = await plannerService.GetNewIdeaBucketAsync(planId);
if (newIdearBucket == null)
{
throw new ApplicationException("Could not found New Idea bucket.");
}
var plannerTask = new PlannerTask
{
PlanId = planId,
BucketId = newIdearBucket.Id,
Title = title,
StartDateTime = startDate,
Assignments = new PlannerAssignments()
};
plannerTask.Assignments.AddAssignee(ownerId);
plannerTask = await graphServiceClient.Planner.Tasks.Request().AddAsync(plannerTask);
//await Task.Delay(3000);
var planerTaskDetails = new PlannerTaskDetails {
Description = description
};
var plannerTaskRequestBuilder = graphServiceClient.Planner.Tasks[plannerTask.Id];
PlannerTaskDetails details = null;
int count = 1;
while (true)
{
try
{
details = await plannerTaskRequestBuilder.Details.Request().GetAsync();
break;
}
catch (Exception ex)
{
if (count < 6)
{
await Task.Delay(1000);
}
else
{
throw new Exception("Task created. But failed to create its details. ", ex);
}
}
count++;
}
details = await plannerTaskRequestBuilder.Details
.Request(new[] { new HeaderOption("If-Match", details.GetEtag()) })
.UpdateAsync(planerTaskDetails);
return(plannerTask);
}
public async Task <PlannerTaskDetails> AddPlannerTaskDetailsAsync(PlannerTaskDetails plannerTaskDetails, string taskId)
{
signalRMessage.sendMessage($"GET: {graphServiceClient.Planner.Tasks[taskId].Details.Request().RequestUrl}");
var originalTaskDescription = await graphServiceClient.Planner.Tasks[taskId].Details.Request().GetAsync();
signalRMessage.sendMessage($"PATCH: {graphServiceClient.Planner.Tasks[taskId].Details.Request().Header("If-Match", originalTaskDescription.GetEtag()).RequestUrl}");
var response = await graphServiceClient.Planner.Tasks[taskId].Details.Request().Header("If-Match", originalTaskDescription.GetEtag()).UpdateAsync(plannerTaskDetails);
return(response);
}
private static async Task UpdateTaskDetailsV2(GraphServiceClient graphClient, string groupId, PlannerTask task, string newFileName, DriveItem attachFile, string myEtag)
{
PlannerTaskDetails taskDetails = new PlannerTaskDetails();
taskDetails = await GetPlannerTaskDetailsAsync(graphClient, task);
taskDetails.AdditionalData =
new Dictionary <string, object>()
{
{ newFileName, attachFile.Name }
};
await graphClient.Planner.Tasks[task.Id].Details
.Request()
.Header("If-Match", myEtag)
.UpdateAsync(taskDetails);
}
private static async Task UpdateTaskDetails(GraphServiceClient graphClient, string groupId, PlannerTask task, DriveItem attachFile)
{
PlannerTaskDetails taskDetails = await GetPlannerTaskDetailsAsync(graphClient, task);
taskDetails.References = new PlannerExternalReferences();
taskDetails.References.AddReference(attachFile.WebUrl, attachFile.Name);
taskDetails.Checklist = new PlannerChecklistItems();
taskDetails.Checklist.AddChecklistItem("Meet Visitor in Lobby");
//not useing anymore
// .Header("Prefer", "return=represendation")
PlannerTaskDetails updatedTask = await graphClient.Planner.Tasks[task.Id].Details.Request()
.Header("If-Match", taskDetails.GetEtag())
.Header("Prefer", "return=represendation")
.UpdateAsync(taskDetails);
}
/// <summary>
/// Update the navigation property details in planner
/// <param name="body"></param>
/// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
/// </summary>
public RequestInformation CreatePatchRequestInformation(PlannerTaskDetails body, Action <DetailsRequestBuilderPatchRequestConfiguration> 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 DetailsRequestBuilderPatchRequestConfiguration();
requestConfiguration.Invoke(requestConfig);
requestInfo.AddRequestOptions(requestConfig.Options);
requestInfo.AddHeaders(requestConfig.Headers);
}
return(requestInfo);
}
private static async Task <PlannerTaskDetails> GetPlannerTaskDetailsAsync(GraphServiceClient graphClient, PlannerTask task)
{
int cnt = 0;
PlannerTaskDetails taskDetails = null;
while (taskDetails == null)
{
//Sometimes takes a little time to create the task, so wait until the item is created
cnt++;
try
{
taskDetails = await graphClient.Planner.Tasks[task.Id].Details.Request().GetAsync();
}
catch (ServiceException se)
{
}
}
return(taskDetails);
}
private void ChangeIssue()
{
HochladenAsync(Attachments, _selectedBucket.Name, _selectedCategory.Description, _selectedGroup.Id);
PlannerAppliedCategories appliedCategories = CreateAppliedCategories(_selectedCategory);
Conversation conversation = CreateConversation(UploadPath, _selectedTask.Title);
var taskDetailsETag = _graphClient.Planner.Tasks[_selectedTask.Id].Details.Request().GetAsync().Result.GetEtag();
var currentConversationthreadId = _graphClient.Planner.Tasks[_selectedTask.Id].Request().GetAsync().Result.ConversationThreadId;
PlannerTask plannerTask = new PlannerTask()
{
PercentComplete = SelectedPercentComplete.Value,
DueDateTime = _selectedDueDate,
AppliedCategories = appliedCategories
};
if (currentConversationthreadId != null)
{
_graphClient.Groups[_selectedGroup.Id].Threads[currentConversationthreadId].Reply(conversation.Threads[0].Posts[0]).Request().PostAsync();
}
else
{
var neuConversationThreadId = _graphClient.Groups[_selectedGroup.Id].Conversations.Request().AddAsync(conversation).Result.Id;
plannerTask.ConversationThreadId = neuConversationThreadId;//neue Thread zugewiesen
}
_graphClient.Planner.Tasks[_selectedTask.Id].Request()
.Header("If-Match", _selectedTask.GetEtag())
.Header("Prefer", "return=representation")
.UpdateAsync(plannerTask);
var currentTaskDetailsEtag = _graphClient.Planner.Tasks[_selectedTask.Id].Details.Request().GetAsync().Result.GetEtag();
PlannerTaskDetails plannerTaskDetails = new PlannerTaskDetails()
{
Description = _description
};
_graphClient.Planner.Tasks[_selectedTask.Id].Details.
Request()
.Header("If-Match", currentTaskDetailsEtag)
.UpdateAsync(plannerTaskDetails);
System.Windows.MessageBox.Show(string.Format("task {0} changed.", _selectedTask.Title));
}
private void CreateIssue()
{
HochladenAsync(Attachments, SelectedBucket.Name, SelectedCategory.Description, _selectedGroup.Id);
PlannerAppliedCategories appliedCategories = CreateAppliedCategories(_selectedCategory);
Conversation conversation = CreateConversation(UploadPath, _selectedTask.Title);
var newConversationId = _graphClient.Groups[_selectedGroup.Id].Conversations.Request().AddAsync(conversation).Result.Id;
PlannerTask plannerTask = new PlannerTask()
{
PlanId = _selectedPlan.Id,
BucketId = _selectedBucket.Id,
Title = _taskTitle,
ConversationThreadId = newConversationId,
PercentComplete = SelectedPercentComplete.Value,
DueDateTime = _selectedDueDate,
AppliedCategories = appliedCategories
};
var createdTask = _graphClient.Planner.Tasks.Request().AddAsync(plannerTask).Result;
string createdTaskDetailsEtag = "";
while (createdTask != null && createdTaskDetailsEtag.Equals(""))
{
try
{ createdTaskDetailsEtag = _graphClient.Planner.Tasks[createdTask.Id].Details.Request().GetAsync().Result.GetEtag(); }
catch (Exception e)
{
Thread.Sleep(500);
}
}
PlannerTaskDetails plannerTaskDetails = new PlannerTaskDetails()
{
Description = _description
};
_graphClient.Planner.Tasks[createdTask.Id].Details.Request()
.Header("If-Match", createdTaskDetailsEtag)
.UpdateAsync(plannerTaskDetails);
System.Windows.MessageBox.Show(string.Format("task {0} created.", createdTask.Title));
}
public async Async.Task PlannerTaskDetailsUpdate()
{
var group = await CreateGroup();
this.testGroup = group;
var plannerPlan = await CreatePlan(group); // You may need to add a Delay in this since there is some latency.
PlannerTask taskToCreate = new PlannerTask();
taskToCreate.PlanId = plannerPlan.Id;
taskToCreate.Title = "New task title";
PlannerTask createdTask = await graphClient.Planner.Tasks.Request().AddAsync(taskToCreate);
PlannerTaskDetails taskDetails = await graphClient.Planner.Tasks[createdTask.Id].Details.Request().GetAsync();
PlannerTaskDetails taskDetailsToUpdate = new PlannerTaskDetails();
taskDetailsToUpdate.Checklist = new PlannerChecklistItems();
string checklistItemId1 = taskDetailsToUpdate.Checklist.AddChecklistItem("Do something");
string checklistItemId2 = taskDetailsToUpdate.Checklist.AddChecklistItem("Do something else");
taskDetailsToUpdate.References = new PlannerExternalReferences();
taskDetailsToUpdate.References.AddReference("http://developer.microsoft.com", "Developer resources");
taskDetailsToUpdate.PreviewType = PlannerPreviewType.Checklist;
taskDetailsToUpdate.Description = "Description of the task";
string etag = taskDetails.GetEtag();
PlannerTaskDetails updatedTaskDetails = await graphClient.Planner.Tasks[createdTask.Id].Details.Request().Header("If-Match", etag).Header("Prefer", "return=representation").UpdateAsync(taskDetailsToUpdate);
Assert.AreEqual("Description of the task", updatedTaskDetails.Description);
Assert.AreEqual(PlannerPreviewType.Checklist, updatedTaskDetails.PreviewType);
Assert.AreEqual(2, updatedTaskDetails.Checklist.Count());
Assert.AreEqual("Do something", updatedTaskDetails.Checklist[checklistItemId1]?.Title);
Assert.AreEqual("Do something else", updatedTaskDetails.Checklist[checklistItemId2]?.Title);
Assert.AreEqual(1, updatedTaskDetails.References.Count());
Assert.AreEqual("Developer resources", updatedTaskDetails.References["http://developer.microsoft.com"]?.Alias);
}
public async System.Threading.Tasks.Task <ActionResult> Import(HttpPostedFileBase file, string PlannerPlan, string clientId)
{
SignalRMessage signalR = new SignalRMessage(clientId);
GraphPlanner graphPlanner = new GraphPlanner(clientId);
try
{
// Get current planner object
var planner = await graphPlanner.GetplannerPlanAsync(PlannerPlan);
// Count imported tasks
int importedTasksCounter = 0;
// Get uploaded json
BinaryReader b = new BinaryReader(file.InputStream);
byte[] binData = b.ReadBytes(file.ContentLength);
string result = Encoding.UTF8.GetString(binData);
JsonReader reader = new JsonTextReader(new StringReader(result));
// Do not parse datetime values
reader.DateParseHandling = DateParseHandling.None;
reader.DateTimeZoneHandling = DateTimeZoneHandling.Unspecified;
JObject trelloBoard = JObject.Load(reader);
// Get trello lists
ArrayList bucketsToCreate = new ArrayList();
foreach (JToken list in trelloBoard.SelectToken("lists"))
{
string bucketName = (string)list["name"];
// check if list was archived
bool isOpen = !(bool)list["closed"];
if (!bucketsToCreate.Contains(bucketName) && isOpen)
{
bucketsToCreate.Add(bucketName);
}
}
// Get existing planner buckets
IEnumerable <PlannerBucket> plannerBuckets = await graphPlanner.GetPlannerBucketsAsync(PlannerPlan);
// Create planner bucket if not exists
foreach (string bucket in bucketsToCreate)
{
try
{
if (!plannerBuckets.ToList().Where(p => p.Name == bucket).Any())
{
PlannerBucket plannerBucket = new PlannerBucket
{
Name = bucket,
PlanId = PlannerPlan
};
var reponse = await graphPlanner.AddPlannerBucketAsync(plannerBucket);
}
}
catch
{
}
}
// Get available planner buckets
plannerBuckets = await graphPlanner.GetPlannerBucketsAsync(PlannerPlan);
// create tasks
foreach (JToken task in trelloBoard.SelectToken("cards"))
{
try
{
// Get name of the trello list which will become a planner bucket
string trelloId = (string)task["idList"];
string name = (string)trelloBoard.SelectToken($"$.lists[?(@.id == '{trelloId}')]")["name"];
// Check if task is in an archived list --> won't be imported
bool isInArchivedList = (bool)trelloBoard.SelectToken($"$.lists[?(@.id == '{trelloId}')]")["closed"];
PlannerTask plannerTask = new PlannerTask
{
PlanId = PlannerPlan,
Title = (string)task["name"],
};
if (isInArchivedList)
{
signalR.sendMessage("Discarding task because stored in an archived list: '" + plannerTask.Title + "'");
}
else
{
try
{
// Get bucketId to store tasks
string bucketId = plannerBuckets.Where(p => p.Name.Equals(name)).First().Id;
plannerTask.BucketId = bucketId;
}
catch
{
}
// Get completed
bool isClosed = bool.Parse((string)task["closed"]);
if (isClosed)
{
plannerTask.PercentComplete = 100;
}
// Get due
string dueDateTime = (string)task["due"];
if (!string.IsNullOrEmpty(dueDateTime))
{
plannerTask.DueDateTime = DateTimeOffset.Parse(dueDateTime);
}
// Get assigned user
try
{
JToken[] assignedToId = task.SelectTokens("idMembers[*]").ToArray();
plannerTask.Assignments = new PlannerAssignments();
// workaround: https://github.com/nicolonsky/ModernWorkplaceConcierge/issues/75#issuecomment-821622465
plannerTask.Assignments.ODataType = null;
foreach (JToken currentUser in assignedToId)
{
if (!string.IsNullOrEmpty((string)currentUser))
{
string assignedToname = (string)trelloBoard.SelectToken($"$.members[?(@.id == '{(string)currentUser}')]")["fullName"];
User user = await GraphHelper.GetUser(assignedToname);
plannerTask.Assignments.AddAssignee(user.Id);
}
}
}
catch
{
}
// Add the task
var request = await graphPlanner.AddPlannerTaskAsync(plannerTask);
signalR.sendMessage("Successfully imported task '" + request.Title + "'");
importedTasksCounter++;
// Add task details like description and attachments
JToken[] attachments = task.SelectTokens("attachments[*]").ToArray();
string taskDescription = (string)task["desc"];
if (!string.IsNullOrEmpty(taskDescription) || attachments.Count() > 0)
{
PlannerTaskDetails plannerTaskDetails = new PlannerTaskDetails();
if (!string.IsNullOrEmpty(taskDescription))
{
plannerTaskDetails.Description = taskDescription;
}
plannerTaskDetails.References = new PlannerExternalReferences();
foreach (JToken attachment in attachments)
{
string attachmentUrl = attachment.Value <string>("url");
string attachmentName = attachment.Value <string>("name");
if (!string.IsNullOrEmpty(attachmentUrl))
{
try
{
plannerTaskDetails.References.AddReference(attachmentUrl, attachmentName);
}
catch
{
}
}
}
try
{
plannerTaskDetails.Checklist = new PlannerChecklistItems();
JToken[] checklists = task.SelectTokens("idChecklists[*]").ToArray();
foreach (JToken checklist in checklists)
{
JToken[] checklistItems = trelloBoard.SelectTokens($"$.checklists[?(@.id == '{(string)checklist}')].checkItems[*].name").ToArray();
int checklistCount = 0;
foreach (JToken checklistItem in checklistItems)
{
string checklistItemName = (string)checklistItem;
// truncate string because checklist items are limited to 100 characters
if (checklistItemName.Length >= 100)
{
signalR.sendMessage("Truncating checklist item: '" + checklistItemName + "' on task: '" + plannerTask.Title + "'. The maximum length in Planner is 100 characters!");
checklistItemName = checklistItemName.Substring(0, 100);
}
if (!(checklistCount >= 20))
{
plannerTaskDetails.Checklist.AddChecklistItem(checklistItemName);
}
else
{
signalR.sendMessage("Discarding checklist item: '" + checklistItemName + "' on task: '" + plannerTask.Title + "' because Planner limit's each card to 20 checklist items!");
}
checklistCount++;
}
}
}
catch (Exception e)
{
signalR.sendMessage("Error: " + e.Message);
}
var response = await graphPlanner.AddPlannerTaskDetailsAsync(plannerTaskDetails, request.Id);
}
}
}
catch (Exception e)
{
signalR.sendMessage("Error: " + e.Message);
}
}
signalR.sendMessage("Success imported: " + importedTasksCounter + " tasks to planner: " + planner.Title);
}
catch (Exception e)
{
signalR.sendMessage("Error: " + e.Message);
}
signalR.sendMessage("Done#!");
return(new HttpStatusCodeResult(204));
}
