public async Task <PlannerBucket> AddPlannerBucketAsync(PlannerBucket plannerBucket)
{
signalRMessage.sendMessage($"POST: {graphServiceClient.Planner.Buckets.Request().RequestUrl}");
var response = await graphServiceClient.Planner.Buckets.Request().AddAsync(plannerBucket);
return(response);
}
public PlannerBucket GetBucket(HttpClient httpClient, string accessToken, string planId)
{
// first try to get the bucket by id
if (_bucket != null)
{
return(_bucket);
}
else
{
try
{
var buckets = PlannerUtility.GetBucketsAsync(httpClient, accessToken, planId).GetAwaiter().GetResult();
if (buckets != null)
{
PlannerBucket bucket = null;
var bucketId = _id ?? _bucket?.Id;
if (bucketId != null)
{
bucket = buckets.FirstOrDefault(b => b.Id == bucketId);
}
if (bucket == null)
{
// by name?
bucket = buckets.FirstOrDefault(b => b.Name.Equals(_id, StringComparison.OrdinalIgnoreCase));
}
return(bucket);
}
}
catch (GraphException ex)
{
throw new PSArgumentException(ex.Error.Message);
}
return(null);
}
}
public async Task <PlannerBucket> CreateBucket(string planId, string bucketName)
{
var plannerBucket = new PlannerBucket()
{
Name = bucketName,
PlanId = planId
};
return(await GraphClient.Planner.Buckets.Request().AddAsync(plannerBucket));
}
/// <summary>
/// Use this API to create a new plannerTask.
/// </summary>
/// <param name="planId">The plannerplan's ID to create a new plannerTask into.</param>
/// <param name="bucket"></param>
/// <param name="sTask"></param>
/// <returns>If successful, this method returns 201 Created response code and plannerTask object in the response body. In case of errors, see HTTP status codes.</returns>
private async Task <PlannerTask> CreateTask(string planId, PlannerBucket bucket, PlannerTask sTask)
{
// C# 8.0 Preview 2 feature.
using var cs = this.GetCodeSection();
if (string.IsNullOrWhiteSpace(planId) ||
bucket == null ||
sTask == null)
{
cs.Warning(Constants.MESSAGE_WARNING_NULLARGUMENTS);
return(null);
}
dynamic body = new ExpandoObject();
body.planId = planId;
body.bucketId = bucket.Id;
body.title = sTask.Title;
body.startDateTime = sTask.StartDateTime;
body.dueDateTime = sTask.DueDateTime;
var bodyContent = JsonConvert.SerializeObject(body);
cs.Debug($"\nBody content:\n-Title: {body.title}\n-Plan Id: {body.planId}");
PlannerTask newTask;
try
{
HttpResponseMessage httpResponseMessage = null;
var retry = new RetryWithExponentialBackoff <HttpResponseMessage>();
await retry.RunAsync(
async() =>
{
httpResponseMessage = await HttpClient.PostAsync(
new Uri(O365Settings.MsGraphBetaEndpoint + $"/planner/tasks"),
new StringContent(bodyContent, 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;
}
var httpResultString = httpResponseMessage.Content.ReadAsStringAsync().Result;
newTask = JsonConvert.DeserializeObject <PlannerTask>(httpResultString);
}
catch (Exception ex)
{
cs.Exception(ex);
throw;
}
return(newTask);
}
private void UpdateTasks(PlannerBucket bucket)
{
SelectedTask = null;
var getPlannerTasks = _graphClient.Planner.Buckets[bucket.Id].Tasks.Request().GetAsync().Result.ToList();
getPlannerTasks.Insert(0, new PlannerTask()
{
Title = _neuAufgabe
});
PlannerTasks = getPlannerTasks;
//zweimal aktualisieren gehts nicht. deswegen hier wird ein Zwischenvariable eingeführt.
//OnPropertyChanged("PlannerTasks");
}
/// <summary>
/// Create new navigation property to buckets for me
/// <param name="body"></param>
/// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
/// </summary>
public RequestInformation CreatePostRequestInformation(PlannerBucket body, Action<BucketsRequestBuilderPostRequestConfiguration> requestConfiguration = default) {
_ = body ?? throw new ArgumentNullException(nameof(body));
var requestInfo = new RequestInformation {
HttpMethod = Method.POST,
UrlTemplate = UrlTemplate,
PathParameters = PathParameters,
};
requestInfo.SetContentFromParsable(RequestAdapter, "application/json", body);
if (requestConfiguration != null) {
var requestConfig = new BucketsRequestBuilderPostRequestConfiguration();
requestConfiguration.Invoke(requestConfig);
requestInfo.AddRequestOptions(requestConfig.Options);
requestInfo.AddHeaders(requestConfig.Headers);
}
return requestInfo;
}
public static async Task <PlannerBucket> AddPlannerBucket(PlannerBucket plannerBucket, string clientId = null)
{
var graphClient = GetAuthenticatedClient();
if (!string.IsNullOrEmpty(clientId))
{
var hubContext = GlobalHost.ConnectionManager.GetHubContext <MwHub>();
hubContext.Clients.Client(clientId).addMessage("POST: " + graphClient.Planner.Buckets.Request().RequestUrl);
}
var response = await graphClient
.Planner
.Buckets
.Request()
.AddAsync(plannerBucket);
return(response);
}
public static PlannerBuckets FromModel(PlannerBucket model)
{
var vm = Mapper.Map <PlannerBucket, PlannerBuckets>(model);
return(vm);
}
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));
}
public PlannerBucketPipeBind(PlannerBucket bucket)
{
_bucket = bucket;
}
public async Task <PlannerBucket> CreateBucketAsync(PlannerBucket bucket)
{
return(await graphClient.Planner.Buckets.Request().AddAsync(bucket));
}
