1367 lines
48 KiB
Plaintext
1367 lines
48 KiB
Plaintext
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Text;
|
|
using System.Threading.Tasks;
|
|
using System.Web;
|
|
|
|
using Newtonsoft.Json.Linq;
|
|
|
|
using C4IT.Logging;
|
|
using System.Reflection;
|
|
using static C4IT.Logging.cLogManager;
|
|
using Newtonsoft.Json;
|
|
using Newtonsoft.Json.Converters;
|
|
|
|
namespace C4IT.MsGraph
|
|
{
|
|
public class cMsGraphSharepoint
|
|
{
|
|
public const string constMsGraphTeamsList = "groups/?$filter=resourceProvisioningOptions/Any(x:x eq 'Team')&$select=id,displayName";
|
|
public const string constMsGraphGroupInfo = "groups/{id}";
|
|
public const string constMsGraphGroupMembers = "groups/{id}/members";
|
|
public const string constMsGraphGroupMembersAdd = "groups/{id}/members/$ref";
|
|
public const string constMsGraphGroupMembersDelete = "groups/{id}/members/{memberId}/$ref";
|
|
public const string constMsGraphGroupOwnersAdd = "groups/{id}/owners/$ref";
|
|
public const string constMsGraphGroupOwnersDelete = "groups/{id}/owners/{memberId}/$ref";
|
|
public const string constMsGraphGroupTransitiveMembers = "groups/{id}/transitiveMembers";
|
|
public const string constMsGraphGroupOwners = "groups/{id}/owners";
|
|
public const string constMsGraphGroupDrive = "groups/{id}/drive";
|
|
public const string constMsGraphDriveInfo = "drives/{id}";
|
|
public const string constMsGraphDriveRoot = "drives/{id}/root";
|
|
public const string constMsGraphFileObjectInfo = "drives/{driveId}/items/{id}";
|
|
public const string constMsGraphFileObjectChildren = "drives/{driveId}/items/{itemId}/children/?$select=id,name,file";
|
|
public const string constMsGraphFileObjectByName = "drives/{driveId}/items/{itemId}/children/?$select=id,name,file&$filter=name eq '{name}'";
|
|
public const string constMsGraphFileObjectPermissions = "/drives/{driveId}/items/{id}/permissions";
|
|
public const string constMsGraphTeamChannelList = "teams/{id}/channels";
|
|
public const string constMsGraphTeamClone = "teams/{id}/clone";
|
|
public const string constMsGraphTeamPrivateChannelList = "teams/{id}/channels?$filter=membershipType eq 'private'";
|
|
public const string constMsGraphTeamChannelInfo = "teams/{groupId}/channels/{id}";
|
|
public const string constMsGraphTeamChannelRoot = "teams/{groupId}/channels/{id}/filesFolder";
|
|
public const string constMsGraphTeamFileObjectPermissionInvite = "drives/{driveId}/items/{id}/invite";
|
|
public const string constMsGraphTeamFileObjectPermissionDelete = "drives/{driveId}/items/{itemId}/permissions/{id}";
|
|
public const string constMsGraphTeamFileObjectPermissionRevokeGrant = "drives/{driveId}/items/{itemId}/permissions/{id}/revokeGrants";
|
|
public const string constMsGraphUserInfo = "users/{email}";
|
|
public cMsGraphBase Base { get; private set; } = null;
|
|
|
|
public bool IsOnline
|
|
{
|
|
get
|
|
{
|
|
if (Base == null)
|
|
return false;
|
|
return Base.IsOnline;
|
|
}
|
|
}
|
|
|
|
public cMsGraphSharepoint(cMsGraphBase Base)
|
|
{
|
|
this.Base = Base;
|
|
}
|
|
|
|
public async Task<cMsGraphCollectionGroups> RequestTeamsListAsync()
|
|
{
|
|
Base.ResetError();
|
|
try
|
|
{
|
|
var Result = await Base.RequestListAsync(constMsGraphTeamsList, UseBeta: true, retryForbidden: true);
|
|
|
|
if (Result != null)
|
|
{
|
|
var RetVal = new cMsGraphCollectionGroups(Result.Count);
|
|
foreach (var Entry in Result)
|
|
{
|
|
var res = new cMsGraphResultGroup(Entry);
|
|
RetVal.Add(res);
|
|
}
|
|
return RetVal;
|
|
}
|
|
}
|
|
catch (Exception E)
|
|
{
|
|
cLogManager.LogException(E);
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
public async Task<cMsGraphResultGroup> RequestGroupInfoAsync(string ID)
|
|
{
|
|
Base.ResetError();
|
|
try
|
|
{
|
|
var strRequest = constMsGraphGroupInfo.Replace("{id}", ID);
|
|
var Result = await Base.RequestAsync(strRequest);
|
|
if (Result != null)
|
|
return new cMsGraphResultGroup(Result);
|
|
}
|
|
catch (Exception E)
|
|
{
|
|
cLogManager.LogException(E);
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
public async Task<cMsGraphResultBase> CloneTeam(string ID, CloneTeamRequest cloneTeamRequest)
|
|
{
|
|
Base.ResetError();
|
|
try
|
|
{
|
|
var strRequest = constMsGraphTeamClone.Replace("{id}", ID);
|
|
var Result = await Base.RequestAsync(strRequest, false, cMsGraphBase.eHttpMethod.post, cloneTeamRequest);
|
|
var Result2 = await GetOperationResult(Result.Result);
|
|
//Base.RequestAsync(Result.Result, false, cMsGraphBase.eHttpMethod.get);
|
|
if (Result2 != null)
|
|
return Result2;
|
|
}
|
|
catch (Exception E)
|
|
{
|
|
cLogManager.LogException(E);
|
|
}
|
|
|
|
return null;
|
|
}
|
|
public async Task<cMsGraphResultBase> GetOperationResult(string operationUrl)
|
|
{
|
|
Base.ResetError();
|
|
|
|
const int maxAttempts = 5;
|
|
const int delaySeconds = 30;
|
|
|
|
for (int attempt = 1; attempt <= maxAttempts; attempt++)
|
|
{
|
|
try
|
|
{
|
|
var result = await Base.RequestAsync(operationUrl, false, cMsGraphBase.eHttpMethod.get);
|
|
if (result == null) continue;
|
|
|
|
switch (result.Result.status.ToLowerInvariant())
|
|
{
|
|
case "notstarted":
|
|
case "inprogress":
|
|
if (attempt == maxAttempts)
|
|
{
|
|
cLogManager.LogEntry($"Maximale Anzahl Versuche erreicht ({maxAttempts}). Operation noch nicht abgeschlossen.", LogLevels.Error);
|
|
return result;
|
|
}
|
|
await Task.Delay(TimeSpan.FromSeconds(delaySeconds));
|
|
break;
|
|
|
|
case "failed":
|
|
cLogManager.LogEntry($"Operation failed: {result.Result.error?.ToString() ?? "Unknown error"}", LogLevels.Error);
|
|
return result;
|
|
|
|
case "succeeded":
|
|
return result;
|
|
|
|
default:
|
|
cLogManager.LogEntry($"Unexpected operation status: {result.Result.status}", LogLevels.Warning);
|
|
return result;
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
cLogManager.LogException(ex);
|
|
return null;
|
|
}
|
|
}
|
|
|
|
cLogManager.LogEntry($"Operation nicht abgeschlossen nach {maxAttempts} Versuchen.", LogLevels.Error);
|
|
return null;
|
|
}
|
|
|
|
|
|
public async Task<cMsGraphResultUser> RequestUserInfoAsync(string email)
|
|
{
|
|
Base.ResetError();
|
|
try
|
|
{
|
|
var strRequest = constMsGraphUserInfo.Replace("{email}", email);
|
|
var Result = await Base.RequestAsync(strRequest);
|
|
if (Result != null)
|
|
return new cMsGraphResultUser(Result);
|
|
}
|
|
catch (Exception E)
|
|
{
|
|
cLogManager.LogException(E);
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
public async Task<cMsGraphCollectionUsers> RequestGroupMembersAsync(string GroupID, string UserId = null)
|
|
{
|
|
return await privRequestGroupMembersAsync(constMsGraphGroupMembers, GroupID, UserId);
|
|
}
|
|
|
|
public async Task<cMsGraphCollectionUsers> RequestGroupTransitiveMembers(string GroupID, string UserId = null)
|
|
{
|
|
return await privRequestGroupMembersAsync(constMsGraphGroupTransitiveMembers, GroupID, UserId);
|
|
}
|
|
|
|
public async Task<cMsGraphCollectionUsers> RequestGroupOwnersAsync(string GroupID, string UserId = null)
|
|
{
|
|
return await privRequestGroupMembersAsync(constMsGraphGroupOwners, GroupID, UserId);
|
|
}
|
|
|
|
private async Task<cMsGraphCollectionUsers> privRequestGroupMembersAsync(string Url, string GroupID, string UserId)
|
|
{
|
|
Base.ResetError();
|
|
try
|
|
{
|
|
var Url2 = Url.Replace("{id}", GroupID);
|
|
if (!string.IsNullOrEmpty(UserId))
|
|
Url2 += $"/?$filter=id eq '{UserId}'";
|
|
var Result = await Base.RequestListAsync(Url2);
|
|
|
|
if (Result != null)
|
|
{
|
|
var RetVal = new cMsGraphCollectionUsers(Result.Count);
|
|
foreach (var Entry in Result)
|
|
{
|
|
var res = new cMsGraphResultUser(Entry);
|
|
if (!string.IsNullOrEmpty(res.UserPrincipalName))
|
|
RetVal.Add(res);
|
|
}
|
|
return RetVal;
|
|
}
|
|
}
|
|
catch (Exception E)
|
|
{
|
|
cLogManager.LogException(E);
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
public async Task<cMsGraphResultDrive> RequestGroupDrive(string GroupID)
|
|
{
|
|
Base.ResetError();
|
|
try
|
|
{
|
|
var strRequest = constMsGraphGroupDrive.Replace("{id}", GroupID);
|
|
var Result = await Base.RequestAsync(strRequest);
|
|
if (Result != null)
|
|
return new cMsGraphResultDrive(Result);
|
|
}
|
|
catch (Exception E)
|
|
{
|
|
cLogManager.LogException(E);
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
public async Task<cMsGraphResultDrive> RequestDriveInfo(string DriveID)
|
|
{
|
|
Base.ResetError();
|
|
try
|
|
{
|
|
var strRequest = constMsGraphDriveInfo.Replace("{id}", DriveID);
|
|
var Result = await Base.RequestAsync(strRequest);
|
|
if (Result != null)
|
|
{
|
|
var RetVal = new cMsGraphResultDrive(Result);
|
|
return RetVal;
|
|
}
|
|
}
|
|
catch (Exception E)
|
|
{
|
|
cLogManager.LogException(E);
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
public async Task<cMsGraphResultFileObject> RequestDriveRoot(cMsGraphResultDrive Drive)
|
|
{
|
|
Base.ResetError();
|
|
try
|
|
{
|
|
var strRequest = constMsGraphDriveRoot.Replace("{id}",Drive.ID);
|
|
var Result = await Base.RequestAsync(strRequest);
|
|
if (Result != null)
|
|
return new cMsGraphResultFileObject(Drive.ID, Result, Drive);
|
|
}
|
|
catch (Exception E)
|
|
{
|
|
cLogManager.LogException(E);
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
public async Task<cMsGraphResultFileObject> RequestFileObjectInfo(string DriveID, string ID, cMsGraphResultDrive Drive = null)
|
|
{
|
|
Base.ResetError();
|
|
try
|
|
{
|
|
var strRequest = constMsGraphFileObjectInfo.Replace("{driveId}", DriveID).Replace("{id}", ID);
|
|
var Result = await Base.RequestAsync(strRequest);
|
|
if (Result != null)
|
|
{
|
|
var RetVal = new cMsGraphResultFileObject(DriveID, Result, Drive);
|
|
return RetVal;
|
|
}
|
|
}
|
|
catch (Exception E)
|
|
{
|
|
cLogManager.LogException(E);
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
public async Task<cMsGraphResultFileObject> RequestFileObjectByName(cMsGraphResultFileObject Folder, string Name)
|
|
{
|
|
Base.ResetError();
|
|
if (Folder == null || Folder.DriveID == null)
|
|
return null;
|
|
|
|
|
|
try
|
|
{
|
|
var strName = HttpUtility.UrlEncode(Name);
|
|
var strRequest = constMsGraphFileObjectByName.Replace("{driveId}", Folder.DriveID);
|
|
strRequest = strRequest.Replace("{itemId}", Folder.ID);
|
|
strRequest = strRequest.Replace("{name}", strName);
|
|
|
|
var Result = await Base.RequestAsync(strRequest);
|
|
if (Result != null)
|
|
{
|
|
if (Result.Result.value.Count >= 1)
|
|
{
|
|
dynamic d = Result.Result.value[0];
|
|
var f = new cMsGraphResultBase(d);
|
|
return new cMsGraphResultFileObject(Folder.DriveID, f, Folder.Drive);
|
|
}
|
|
}
|
|
}
|
|
catch (Exception E)
|
|
{
|
|
cLogManager.LogException(E);
|
|
}
|
|
|
|
return null;
|
|
|
|
}
|
|
|
|
public async Task<cMsGraphCollectionFileObjects> RequestFileObjectSubitems(string DriveID, string ID, bool Folders, cMsGraphResultDrive Drive = null)
|
|
{
|
|
Base.ResetError();
|
|
try
|
|
{
|
|
var strRequest = constMsGraphFileObjectChildren.Replace("{driveId}", DriveID).Replace("{itemId}", ID);
|
|
var Result = await Base.RequestListAsync(strRequest);
|
|
if (Result != null)
|
|
{
|
|
var RetVal = new cMsGraphCollectionFileObjects();
|
|
foreach (var Entry in Result)
|
|
{
|
|
var item = new cMsGraphResultFileObject(DriveID, Entry, Drive);
|
|
if (item.IsFolder ^ !Folders)
|
|
RetVal.Add(item);
|
|
}
|
|
return RetVal;
|
|
}
|
|
}
|
|
catch (Exception E)
|
|
{
|
|
cLogManager.LogException(E);
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
public async Task<cMsGraphCollectionPermissions> RequestFileObjectPermissions(cMsGraphResultFileObject Item)
|
|
{
|
|
Base.ResetError();
|
|
try
|
|
{
|
|
if (Item.DriveID == null)
|
|
return null;
|
|
|
|
var strRequest = constMsGraphFileObjectPermissions.Replace("{driveId}", Item.DriveID).Replace("{id}", Item.ID);
|
|
var Result = await Base.RequestListAsync(strRequest);
|
|
if (Result != null)
|
|
{
|
|
var RetVal = new cMsGraphCollectionPermissions();
|
|
foreach (var Entry in Result)
|
|
{
|
|
var item = cMsGraphResultPermission.CreateInstance(Item, Entry);
|
|
if (item != null)
|
|
RetVal.Add(item);
|
|
}
|
|
return RetVal;
|
|
}
|
|
}
|
|
catch (Exception E)
|
|
{
|
|
cLogManager.LogException(E);
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
public async Task<cMsGraphCollectionChannels> RequestTeamChannels(cMsGraphResultGroup Team, bool OnlyPrivate = false)
|
|
{
|
|
Base.ResetError();
|
|
try
|
|
{
|
|
var strUrl = constMsGraphTeamChannelList;
|
|
if (OnlyPrivate)
|
|
strUrl = constMsGraphTeamPrivateChannelList;
|
|
var strRequest = strUrl.Replace("{id}", Team.ID);
|
|
var Result = await Base.RequestListAsync(strRequest, retryForbidden: true);
|
|
if (Result != null)
|
|
{
|
|
var RetVal = new cMsGraphCollectionChannels(Result.Count);
|
|
foreach (var Entry in Result)
|
|
{
|
|
var item = new cMsGraphResultChannel(Team.ID, Entry, Team);
|
|
RetVal.Add(item);
|
|
}
|
|
return RetVal;
|
|
}
|
|
else
|
|
{
|
|
}
|
|
}
|
|
catch (Exception E)
|
|
{
|
|
cLogManager.LogException(E);
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
public async Task<cMsGraphResultChannel> RequestChannelInfo(string TeamsID, string ChannelID, cMsGraphResultGroup Team = null)
|
|
{
|
|
Base.ResetError();
|
|
try
|
|
{
|
|
var strRequest = constMsGraphTeamChannelInfo.Replace("{groupId}", TeamsID).Replace("{id}", ChannelID);
|
|
var Result = await Base.RequestAsync(strRequest);
|
|
if (Result != null)
|
|
{
|
|
var RetVal = new cMsGraphResultChannel(TeamsID, Result, Team);
|
|
return RetVal;
|
|
}
|
|
}
|
|
catch (Exception E)
|
|
{
|
|
cLogManager.LogException(E);
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
public async Task<cMsGraphResultChannelRoot> RequestChannelRoot(cMsGraphResultChannel Channel)
|
|
{
|
|
Base.ResetError();
|
|
try
|
|
{
|
|
var strRequest = constMsGraphTeamChannelRoot.Replace("{groupId}", Channel.TeamID).Replace("{id}", Channel.ID);
|
|
var Result = await Base.RequestAsync(strRequest, retryForbidden: true);
|
|
if (Result != null)
|
|
{
|
|
var RetVal = new cMsGraphResultChannelRoot(Channel, Result);
|
|
return RetVal;
|
|
}
|
|
}
|
|
catch (Exception E)
|
|
{
|
|
cLogManager.LogException(E);
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
public async Task<bool> AddGroupMembership(cMsGraphResultGroup group, bool owner, cMsGraphResultUser user)
|
|
{
|
|
Base.ResetError();
|
|
try
|
|
{
|
|
string strRequest;
|
|
if (owner)
|
|
strRequest = constMsGraphGroupOwnersAdd;
|
|
else
|
|
strRequest = constMsGraphGroupMembersAdd;
|
|
|
|
strRequest= strRequest.Replace("{id}", group.ID);
|
|
var Request = new AddGroupMemberRequest()
|
|
{
|
|
oDataId = user.ODataId
|
|
};
|
|
var Result = await Base.RequestAsync(strRequest, httpMethod: cMsGraphBase.eHttpMethod.post, JsonData: Request);
|
|
if (Result == null)
|
|
return false;
|
|
|
|
}
|
|
catch (Exception E)
|
|
{
|
|
cLogManager.LogException(E);
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
public async Task<bool> DeleteGroupMembership(cMsGraphResultGroup group, bool owner, cMsGraphResultUser user)
|
|
{
|
|
Base.ResetError();
|
|
try
|
|
{
|
|
string strRequest;
|
|
if (owner)
|
|
strRequest = constMsGraphGroupOwnersDelete;
|
|
else
|
|
strRequest = constMsGraphGroupMembersDelete;
|
|
|
|
strRequest = strRequest.Replace("{id}", group.ID).Replace("{memberId}", user.ID);
|
|
var Result = await Base.RequestAsync(strRequest, httpMethod: cMsGraphBase.eHttpMethod.delete);
|
|
if (Result == null)
|
|
return false;
|
|
|
|
}
|
|
catch (Exception E)
|
|
{
|
|
cLogManager.LogException(E);
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
public async Task<List<cMsGraphResultPermission>> AddFileObjectPermission(cMsGraphResultFileObject Item, IEnumerable<cMsGraphResultPermission.ePermissionRole> Roles, cMsGraphResultPermission.eDriveReceipientType RecipientType, string RecipientID, bool RequireSignIn = true, bool SendInvitation = false, string Message = null)
|
|
{
|
|
Base.ResetError();
|
|
try
|
|
{
|
|
if (Item?.ID == null)
|
|
return null;
|
|
if (Item?.DriveID == null)
|
|
return null;
|
|
|
|
var Recipient = DriveRecipient.Create(RecipientType, RecipientID);
|
|
var Recipients = new List<DriveRecipient>() { Recipient };
|
|
|
|
var roles = new List<string>();
|
|
foreach (var R in Roles)
|
|
roles.Add(R.ToString());
|
|
|
|
if (!SendInvitation)
|
|
RequireSignIn = true;
|
|
|
|
var Request = new AddPermissionRequest()
|
|
{
|
|
requireSignIn = RequireSignIn,
|
|
sendInvitation = SendInvitation,
|
|
message = Message,
|
|
recipients = Recipients,
|
|
roles = roles
|
|
};
|
|
|
|
var strRequest = constMsGraphTeamFileObjectPermissionInvite.Replace("{driveId}", Item.DriveID).Replace("{id}", Item.ID);
|
|
|
|
var Result = await Base.RequestAsync(strRequest, httpMethod: cMsGraphBase.eHttpMethod.post, JsonData: Request);
|
|
if (Result == null)
|
|
return null;
|
|
if (!Result.Result.TryGetValue("value", out JToken Value))
|
|
return null;
|
|
|
|
if (Result.Result.value.Count <= 0)
|
|
return null;
|
|
|
|
var RetVal = new List<cMsGraphResultPermission>();
|
|
|
|
foreach (dynamic Entry in Result.Result.value)
|
|
{
|
|
var Entry2 = new cMsGraphResultBase(Entry);
|
|
var Perm = cMsGraphResultPermission.CreateInstance(Item, Entry2);
|
|
RetVal.Add(Perm);
|
|
}
|
|
return RetVal;
|
|
}
|
|
catch (Exception E)
|
|
{
|
|
cLogManager.LogException(E);
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
public async Task<bool> DeleteFileObjectPermission(cMsGraphResultPermission Permission)
|
|
{
|
|
Base.ResetError();
|
|
try
|
|
{
|
|
if (Permission?.ID == null)
|
|
return false;
|
|
if (Permission?.Item?.ID == null)
|
|
return false;
|
|
if (Permission?.Item?.DriveID == null)
|
|
return false;
|
|
|
|
var strRequest = constMsGraphTeamFileObjectPermissionDelete.Replace("{driveId}", Permission.Item.DriveID).Replace("{itemId}", Permission.Item.ID).Replace("{id}", Permission.ID);
|
|
|
|
var Result = await Base.RequestAsync(strRequest, httpMethod: cMsGraphBase.eHttpMethod.delete);
|
|
if (Result != null)
|
|
return true;
|
|
}
|
|
catch (Exception E)
|
|
{
|
|
cLogManager.LogException(E);
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
public async Task<cMsGraphResultPermission> RevokeFileObjectPermissionGrant(cMsGraphResultPermission Permission, cMsGraphResultPermission.eDriveReceipientType RecipientType, string RecipientID)
|
|
{
|
|
Base.ResetError();
|
|
try
|
|
{
|
|
if (Permission?.ID == null)
|
|
return null;
|
|
if (Permission?.Item?.ID == null)
|
|
return null;
|
|
if (Permission?.Item?.DriveID == null)
|
|
return null;
|
|
|
|
var strRequest = constMsGraphTeamFileObjectPermissionRevokeGrant.Replace("{driveId}", Permission.Item.DriveID).Replace("{itemId}", Permission.Item.ID).Replace("{id}", Permission.ID);
|
|
|
|
var Recipient = DriveRecipient.Create(RecipientType, RecipientID);
|
|
var Grantees = new List<DriveRecipient>()
|
|
{
|
|
Recipient
|
|
};
|
|
var RequestData = new RevokeGrantRequest()
|
|
{
|
|
grantees = Grantees
|
|
};
|
|
|
|
var Result = await Base.RequestAsync(strRequest, UseBeta: true, httpMethod: cMsGraphBase.eHttpMethod.post, JsonData: RequestData);
|
|
if (Result != null)
|
|
{
|
|
var RetVal = new cMsGraphResultPermission(Permission.Item, Result);
|
|
return RetVal;
|
|
}
|
|
}
|
|
catch (Exception E)
|
|
{
|
|
cLogManager.LogException(E);
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
public class CloneTeamRequest
|
|
{
|
|
[JsonConverter(typeof(StringEnumConverter))]
|
|
public enum TeamVisibilityType
|
|
{
|
|
[JsonProperty("private")]
|
|
Private = 0,
|
|
[JsonProperty("public")]
|
|
Public = 1,
|
|
[JsonProperty("hiddenMembership")]
|
|
HiddenMembership = 2
|
|
}
|
|
|
|
[Flags]
|
|
public enum ClonableTeamParts
|
|
{
|
|
None = 0,
|
|
[JsonProperty("apps")]
|
|
Apps = 1,
|
|
[JsonProperty("tabs")]
|
|
Tabs = 2,
|
|
[JsonProperty("settings")]
|
|
Settings = 4,
|
|
[JsonProperty("channels")]
|
|
Channels = 8,
|
|
[JsonProperty("members")]
|
|
Members = 16
|
|
}
|
|
|
|
[JsonProperty("displayName", NullValueHandling = NullValueHandling.Ignore)]
|
|
public string DisplayName { get; set; }
|
|
|
|
[JsonProperty("description", NullValueHandling = NullValueHandling.Ignore)]
|
|
public string Description { get; set; }
|
|
|
|
[JsonProperty("mailNickname", NullValueHandling = NullValueHandling.Ignore)]
|
|
public string MailNickname { get; set; }
|
|
|
|
[JsonProperty("partsToClone", NullValueHandling = NullValueHandling.Ignore)]
|
|
public string PartsToClone { get; set; }
|
|
|
|
[JsonProperty("visibility")]
|
|
[JsonConverter(typeof(StringEnumConverter))]
|
|
public TeamVisibilityType Visibility { get; set; }
|
|
|
|
public void SetClonableParts(ClonableTeamParts parts)
|
|
{
|
|
var partList = new System.Collections.Generic.List<string>();
|
|
if (parts.HasFlag(ClonableTeamParts.Apps)) partList.Add("apps");
|
|
if (parts.HasFlag(ClonableTeamParts.Tabs)) partList.Add("tabs");
|
|
if (parts.HasFlag(ClonableTeamParts.Settings)) partList.Add("settings");
|
|
if (parts.HasFlag(ClonableTeamParts.Channels)) partList.Add("channels");
|
|
if (parts.HasFlag(ClonableTeamParts.Members)) partList.Add("members");
|
|
PartsToClone = string.Join(",", partList);
|
|
}
|
|
}
|
|
|
|
private class AddPermissionRequest
|
|
{
|
|
public bool requireSignIn { get; set; }
|
|
public bool sendInvitation { get; set; }
|
|
public string message { get; set; }
|
|
public IEnumerable<string> roles { get; set; }
|
|
public IEnumerable<DriveRecipient> recipients { get; set; }
|
|
}
|
|
private class AddGroupMemberRequest
|
|
{
|
|
[JsonProperty("@odata.id")]
|
|
public string oDataId { get; set; }
|
|
}
|
|
|
|
private class DriveRecipient
|
|
{
|
|
public string email { get; set; }
|
|
public string alias { get; set; }
|
|
public string objectId { get; set; }
|
|
|
|
public static DriveRecipient Create(cMsGraphResultPermission.eDriveReceipientType RecipientType, string RecipientID)
|
|
{
|
|
var Recipient = new DriveRecipient();
|
|
switch (RecipientType)
|
|
{
|
|
case cMsGraphResultPermission.eDriveReceipientType.objectId:
|
|
Recipient.objectId = RecipientID;
|
|
break;
|
|
case cMsGraphResultPermission.eDriveReceipientType.alias:
|
|
Recipient.email = RecipientID;
|
|
break;
|
|
default:
|
|
Recipient.email = RecipientID;
|
|
break;
|
|
}
|
|
return Recipient;
|
|
}
|
|
}
|
|
|
|
private class RevokeGrantRequest
|
|
{
|
|
public IEnumerable<DriveRecipient> grantees { get; set; }
|
|
}
|
|
}
|
|
|
|
public class cMsGraphResultGroup : cMsGraphResultBase
|
|
{
|
|
public string Description { get; private set; } = null;
|
|
public string SID { get; private set; } = null;
|
|
public string Visibility { get; private set; } = null;
|
|
public string MailEnabled { get; private set; } = null;
|
|
public string MailAddress { get; private set; } = null;
|
|
|
|
public cMsGraphResultDrive Drive { get; private set; } = null;
|
|
|
|
public cMsGraphCollectionChannels Channels { get; private set; } = null;
|
|
|
|
public cMsGraphResultGroup(cMsGraphResultBase Result) : base(Result)
|
|
{
|
|
try { Description = Result.Result.description; } catch { };
|
|
try { SID = Result.Result.securityIdentifier; } catch { };
|
|
try { Visibility = Result.Result.visibility; } catch { };
|
|
try { MailEnabled = Result.Result.mailEnabled; } catch { };
|
|
try { MailAddress = Result.Result.mail; } catch { };
|
|
}
|
|
|
|
public async Task<bool> AddMember()
|
|
{
|
|
await Task.Delay(0);
|
|
return false;
|
|
}
|
|
|
|
public async Task<bool> ResolveDrive(cMsGraphSharepoint SP)
|
|
{
|
|
Drive = await SP.RequestGroupDrive(ID);
|
|
|
|
return Drive != null;
|
|
}
|
|
|
|
public async Task<bool> ResolveChannels(cMsGraphSharepoint SP, bool OnlyPrivate = false)
|
|
{
|
|
Channels = await SP.RequestTeamChannels(this, OnlyPrivate);
|
|
|
|
return Channels != null;
|
|
}
|
|
|
|
public async Task<cMsGraphCollectionUsers> GetMembersAsync(cMsGraphSharepoint SP)
|
|
{
|
|
var CM = MethodBase.GetCurrentMethod();
|
|
LogMethodBegin(CM);
|
|
try
|
|
{
|
|
var RetVal = await SP.RequestGroupMembersAsync(this.ID);
|
|
return RetVal;
|
|
}
|
|
catch (Exception E)
|
|
{
|
|
LogException(E);
|
|
return null;
|
|
}
|
|
finally
|
|
{
|
|
LogMethodEnd(CM);
|
|
}
|
|
|
|
|
|
}
|
|
|
|
public async Task<cMsGraphCollectionUsers> GetOwnersAsync(cMsGraphSharepoint SP)
|
|
{
|
|
var CM = MethodBase.GetCurrentMethod();
|
|
LogMethodBegin(CM);
|
|
try
|
|
{
|
|
var RetVal = await SP.RequestGroupOwnersAsync(this.ID);
|
|
return RetVal;
|
|
}
|
|
catch (Exception E)
|
|
{
|
|
LogException(E);
|
|
return null;
|
|
}
|
|
finally
|
|
{
|
|
LogMethodEnd(CM);
|
|
}
|
|
|
|
|
|
}
|
|
}
|
|
|
|
public class cMsGraphCollectionGroups : SortedList<string,string>
|
|
{
|
|
public cMsGraphCollectionGroups() {}
|
|
public cMsGraphCollectionGroups(int n) : base(n) { }
|
|
|
|
public void Add(cMsGraphResultGroup Group)
|
|
{
|
|
if (!string.IsNullOrEmpty(Group.DisplayName))
|
|
if (!this.ContainsKey(Group.DisplayName))
|
|
this.Add(Group.DisplayName, Group.ID);
|
|
}
|
|
}
|
|
|
|
public class cMsGraphResultChannel : cMsGraphResultBase
|
|
{
|
|
public string Description { get; private set; } = null;
|
|
public string IsFavoriteByDefault { get; private set; } = null;
|
|
public string MembershipType { get; private set; } = null;
|
|
public string MailAddress { get; private set; } = null;
|
|
|
|
public string TeamID { get; private set; } = null;
|
|
public cMsGraphResultGroup Team { get; private set; } = null;
|
|
|
|
public cMsGraphResultFileObject RootFolder { get; private set; } = null;
|
|
public bool RootFolderResolved { get; private set; } = false;
|
|
|
|
public cMsGraphResultChannel(string TeamID, cMsGraphResultBase Result, cMsGraphResultGroup Team = null) : base(Result)
|
|
{
|
|
this.TeamID = TeamID;
|
|
this.Team = Team;
|
|
try { Description = Result.Result.description; } catch { };
|
|
try { IsFavoriteByDefault = Result.Result.isFavoriteByDefault; } catch { };
|
|
try { MembershipType = Result.Result.membershipType; } catch { };
|
|
try { MailAddress = Result.Result.mail; } catch { };
|
|
}
|
|
|
|
public async Task<bool> ResolveRootFolder(cMsGraphSharepoint SP)
|
|
{
|
|
if (Team == null)
|
|
{
|
|
Team = await SP.RequestGroupInfoAsync(TeamID);
|
|
if (Team == null)
|
|
return false;
|
|
}
|
|
|
|
RootFolderResolved = true;
|
|
|
|
if (Team.Drive == null)
|
|
if (!await Team.ResolveDrive(SP))
|
|
return false;
|
|
|
|
if (Team.Drive.Root == null)
|
|
if (!await Team.Drive.ResolveRoot(SP))
|
|
return false;
|
|
|
|
var RF = await SP.RequestChannelRoot(this);
|
|
if (RF != null)
|
|
if (!string.IsNullOrEmpty(RF.DriveID))
|
|
{
|
|
cMsGraphResultDrive dr = null;
|
|
if ((Team.Drive != null) && (Team.Drive.ID == RF.DriveID))
|
|
dr = Team.Drive;
|
|
else if (await RF.ResolveDrive(SP))
|
|
dr = RF.Drive;
|
|
|
|
if (dr != null)
|
|
RootFolder = await SP.RequestFileObjectInfo(dr.ID, RF.ID, dr);
|
|
}
|
|
|
|
return RootFolder != null;
|
|
}
|
|
|
|
}
|
|
|
|
public class cMsGraphCollectionChannels : SortedList<string, cMsGraphResultChannel>
|
|
{
|
|
public cMsGraphCollectionChannels() { }
|
|
public cMsGraphCollectionChannels(int n) : base(n) { }
|
|
|
|
public void Add(cMsGraphResultChannel Channel)
|
|
{
|
|
if (!this.ContainsKey(Channel.DisplayName))
|
|
this.Add(Channel.DisplayName, Channel);
|
|
}
|
|
}
|
|
|
|
public class cMsGraphResultDrive : cMsGraphResultBase
|
|
{
|
|
public string DriveType { get; private set; } = null;
|
|
|
|
public cMsGraphResultFileObject Root { get; private set; } = null;
|
|
|
|
public cMsGraphResultDrive(cMsGraphResultBase Result) : base(Result)
|
|
{
|
|
try { DriveType = Result.Result.driveType; } catch { };
|
|
}
|
|
|
|
public async Task<bool> ResolveRoot(cMsGraphSharepoint SP)
|
|
{
|
|
Root = await SP.RequestDriveRoot(this);
|
|
|
|
return Root != null;
|
|
}
|
|
|
|
}
|
|
|
|
public class cMsGraphResultPermission : cMsGraphResultBase
|
|
{
|
|
public enum eDriveReceipientType { email, alias, objectId};
|
|
|
|
public enum ePermissionRole { owner, read, write };
|
|
|
|
|
|
static public ePermissionRole getRole(string s)
|
|
{
|
|
switch (s.ToLowerInvariant())
|
|
{
|
|
case "owner":
|
|
return ePermissionRole.owner;
|
|
case "write":
|
|
return ePermissionRole.write;
|
|
default:
|
|
return ePermissionRole.read;
|
|
}
|
|
}
|
|
|
|
public cMsGraphResultFileObject Item { get; private set; } = null;
|
|
|
|
public List<cMsGraphPermissionIdentity> Identities { get; private set; } = new List<cMsGraphPermissionIdentity>();
|
|
|
|
public List<ePermissionRole> Roles { get; private set; } = new List<ePermissionRole>();
|
|
|
|
public bool isInherited { get; private set; } = false;
|
|
|
|
public cMsGraphResultPermission(cMsGraphResultFileObject Item, cMsGraphResultBase Result) : base(Result)
|
|
{
|
|
try
|
|
{
|
|
this.Item = Item;
|
|
|
|
if (Result.Result.TryGetValue("roles", out JToken JT1))
|
|
{
|
|
Roles = new List<ePermissionRole>(Result.Result.roles.Count);
|
|
foreach (dynamic Entry in Result.Result.roles)
|
|
Roles.Add(getRole( Entry.ToString()));
|
|
}
|
|
|
|
if (Result.Result.TryGetValue("inheritedFrom", out JToken JT))
|
|
{
|
|
isInherited = true;
|
|
}
|
|
}
|
|
catch (Exception E)
|
|
{
|
|
cLogManager.LogException(E);
|
|
}
|
|
}
|
|
|
|
static public cMsGraphResultPermission CreateInstance(cMsGraphResultFileObject Item, cMsGraphResultBase Result)
|
|
{
|
|
if (PermissionDirect.Check(Result.Result))
|
|
return new PermissionDirect(Item, Result);
|
|
|
|
if (PermissionLink.Check(Result.Result))
|
|
return new PermissionLink(Item, Result);
|
|
|
|
return new cMsGraphResultPermission(Item, Result);
|
|
}
|
|
|
|
public async Task<bool> Delete(cMsGraphSharepoint SP)
|
|
{
|
|
try
|
|
{
|
|
var RetVal = await SP.DeleteFileObjectPermission(this);
|
|
return RetVal;
|
|
}
|
|
catch (Exception E)
|
|
{
|
|
cLogManager.LogException(E);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public async Task<bool> RevokeGrant(cMsGraphSharepoint SP, cMsGraphResultPermission.eDriveReceipientType RecipientType, string RecipientID)
|
|
{
|
|
try
|
|
{
|
|
if (this is cMsGraphResultPermission.PermissionDirect)
|
|
{
|
|
var RetVal = await SP.DeleteFileObjectPermission(this);
|
|
return RetVal;
|
|
}
|
|
else if (this is cMsGraphResultPermission.PermissionLink)
|
|
{
|
|
var RetVal = await SP.RevokeFileObjectPermissionGrant(this, RecipientType, RecipientID);
|
|
if (RetVal != null)
|
|
return true;
|
|
}
|
|
|
|
}
|
|
catch (Exception E)
|
|
{
|
|
cLogManager.LogException(E);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public class PermissionDirect : cMsGraphResultPermission
|
|
{
|
|
public PermissionDirect(cMsGraphResultFileObject Item, cMsGraphResultBase Result) :
|
|
base(Item, Result)
|
|
{
|
|
try
|
|
{
|
|
if (Result.Result.TryGetValue("grantedTo", out JToken JT1))
|
|
{
|
|
var Identity = new cMsGraphPermissionIdentity(Result.Result.grantedTo);
|
|
Identities.Clear();
|
|
Identities.Add(Identity);
|
|
}
|
|
}
|
|
catch (Exception E)
|
|
{
|
|
cLogManager.LogException(E);
|
|
}
|
|
|
|
}
|
|
|
|
public static bool Check(dynamic Result)
|
|
{
|
|
try
|
|
{
|
|
if (Result.TryGetValue("grantedTo", out JToken JT1))
|
|
if (Result.grantedTo.TryGetValue("user", out JToken JT2))
|
|
return true;
|
|
}
|
|
catch (Exception E)
|
|
{
|
|
cLogManager.LogException(E);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
}
|
|
|
|
public class PermissionLink : cMsGraphResultPermission
|
|
{
|
|
public string Scope { get; private set; } = null;
|
|
public string Type { get; private set; } = null;
|
|
public string PreventsDownload { get; private set; } = null;
|
|
public string WebUrl { get; private set; } = null;
|
|
|
|
public PermissionLink(cMsGraphResultFileObject Item, cMsGraphResultBase Result) :
|
|
base(Item, Result)
|
|
{
|
|
try
|
|
{
|
|
if (Result.Result.TryGetValue("link", out JToken JT1))
|
|
{
|
|
dynamic lnk = Result.Result.link;
|
|
if (lnk.TryGetValue("type", out JToken JT2))
|
|
Type = lnk.type;
|
|
if (lnk.TryGetValue("scope", out JToken JT3))
|
|
Scope = lnk.scope;
|
|
if (lnk.TryGetValue("preventsDownload", out JToken JT4))
|
|
PreventsDownload = lnk.preventsDownload;
|
|
if (lnk.TryGetValue("webUrl", out JToken JT5))
|
|
WebUrl = lnk.webUrl;
|
|
}
|
|
if (Result.Result.TryGetValue("grantedToIdentities", out JToken JT6))
|
|
{
|
|
Identities.Clear();
|
|
foreach (dynamic Entry in Result.Result.grantedToIdentities)
|
|
{
|
|
try
|
|
{
|
|
var Ident = new cMsGraphPermissionIdentity(Entry);
|
|
if (Ident != null)
|
|
Identities.Add(Ident);
|
|
|
|
}
|
|
catch (Exception E)
|
|
{
|
|
cLogManager.LogException(E);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
catch (Exception E)
|
|
{
|
|
cLogManager.LogException(E);
|
|
}
|
|
|
|
}
|
|
|
|
public static bool Check(dynamic Result)
|
|
{
|
|
try
|
|
{
|
|
if (Result.TryGetValue("link", out JToken JT1))
|
|
return true;
|
|
}
|
|
catch (Exception E)
|
|
{
|
|
cLogManager.LogException(E);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
}
|
|
|
|
public class cMsGraphPermissionIdentity
|
|
{
|
|
public enum eIdentityType { unknown = 0, user, device, application, };
|
|
|
|
public eIdentityType IdentityType { get; private set; } = eIdentityType.unknown;
|
|
public string ID { get; private set; } = null;
|
|
public string EMail { get; private set; } = null;
|
|
public string DisplayName { get; private set; } = null;
|
|
|
|
public cMsGraphPermissionIdentity(dynamic Result)
|
|
{
|
|
try
|
|
{
|
|
dynamic ident = null;
|
|
|
|
if (Result.TryGetValue("user", out JToken JT1))
|
|
{
|
|
ident = Result.user;
|
|
IdentityType = eIdentityType.user;
|
|
}
|
|
else if (Result.TryGetValue("device", out JToken JT2))
|
|
{
|
|
ident = Result.device;
|
|
IdentityType = eIdentityType.device;
|
|
}
|
|
else if (Result.TryGetValue("application", out JToken JT3))
|
|
{
|
|
ident = Result.application;
|
|
IdentityType = eIdentityType.application;
|
|
}
|
|
|
|
if (ident != null)
|
|
if (ident.TryGetValue("displayName", out JToken JT3))
|
|
DisplayName = ident.displayName;
|
|
if (ident.TryGetValue("id", out JToken JT4))
|
|
ID = ident.id;
|
|
if (ident.TryGetValue("email", out JToken JT5))
|
|
EMail = ident.email;
|
|
}
|
|
catch (Exception E)
|
|
{
|
|
cLogManager.LogException(E);
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
public class cMsGraphCollectionPermissions : List<cMsGraphResultPermission>
|
|
{
|
|
public cMsGraphCollectionPermissions() { }
|
|
public cMsGraphCollectionPermissions(int n) : base(n) { }
|
|
|
|
}
|
|
|
|
public class cMsGraphResultFileObject : cMsGraphResultBase
|
|
{
|
|
public readonly string DriveID = null;
|
|
|
|
public readonly cMsGraphResultDrive Drive = null;
|
|
|
|
public bool IsFolder { get; private set; } = false;
|
|
|
|
public string WebUrl { get; private set; } = null;
|
|
|
|
public cMsGraphCollectionFileObjects Folders { get; private set; } = null;
|
|
public cMsGraphCollectionFileObjects Files { get; private set; } = null;
|
|
|
|
public cMsGraphCollectionPermissions Permissions { get; private set; } = null;
|
|
|
|
public cMsGraphResultFileObject(string DriveID, cMsGraphResultBase Result, cMsGraphResultDrive Drive = null) : base(Result)
|
|
{
|
|
this.DriveID = DriveID;
|
|
this.Drive = Drive;
|
|
|
|
try
|
|
{
|
|
IsFolder = !Result.Result.TryGetValue("file", out JToken JT1);
|
|
WebUrl = cMsGraphResultBase.GetStringFromDynamic(Result.Result, "webUrl");
|
|
}
|
|
catch { }
|
|
}
|
|
|
|
public async Task<bool> ResolveFolders(cMsGraphSharepoint SP)
|
|
{
|
|
Folders = await SP.RequestFileObjectSubitems(this.DriveID, this.ID, true, this.Drive);
|
|
|
|
return Folders != null;
|
|
}
|
|
|
|
public async Task<bool> ResolveFiles(cMsGraphSharepoint SP)
|
|
{
|
|
Files = await SP.RequestFileObjectSubitems(this.DriveID, this.ID, true, this.Drive);
|
|
|
|
return Files != null;
|
|
}
|
|
|
|
public async Task<bool> ResolvePermissions(cMsGraphSharepoint SP)
|
|
{
|
|
Permissions = await SP.RequestFileObjectPermissions(this);
|
|
|
|
return Permissions != null;
|
|
}
|
|
|
|
public async Task<List<cMsGraphResultPermission>> AddPermission(cMsGraphSharepoint SP, IEnumerable<cMsGraphResultPermission.ePermissionRole> Roles, cMsGraphResultPermission.eDriveReceipientType ReceipientType , string RecipientID, bool RequireSignIn = true, bool SendInvitation = false, string Message = null)
|
|
{
|
|
try
|
|
{
|
|
var RetVal = await SP.AddFileObjectPermission(this, Roles, ReceipientType, RecipientID, RequireSignIn, SendInvitation, Message);
|
|
return RetVal;
|
|
}
|
|
catch (Exception E)
|
|
{
|
|
cLogManager.LogException(E);
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
public async Task<bool> RemovePermission(cMsGraphSharepoint SP, cMsGraphResultPermission.ePermissionRole Role, string RecipientID)
|
|
{
|
|
try
|
|
{
|
|
var RetVal = await ResolvePermissions(SP);
|
|
if (!RetVal || Permissions == null)
|
|
return true;
|
|
|
|
var Found = false;
|
|
foreach (var Entry in Permissions)
|
|
{
|
|
if (Entry.Identities == null || Entry.Roles == null)
|
|
continue;
|
|
|
|
if (!Entry.Roles.Contains(Role))
|
|
continue;
|
|
|
|
foreach (var Identity in Entry.Identities)
|
|
{
|
|
var Revoked = false;
|
|
if (Identity.ID == RecipientID)
|
|
Revoked = await Entry.RevokeGrant(SP, cMsGraphResultPermission.eDriveReceipientType.objectId, RecipientID);
|
|
else if (Identity.EMail?.ToUpperInvariant() == RecipientID.ToUpperInvariant())
|
|
Revoked = await Entry.RevokeGrant(SP, cMsGraphResultPermission.eDriveReceipientType.email, RecipientID);
|
|
|
|
Found |= Revoked;
|
|
}
|
|
}
|
|
|
|
return Found;
|
|
}
|
|
catch (Exception E)
|
|
{
|
|
cLogManager.LogException(E);
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
}
|
|
|
|
public class cMsGraphCollectionFileObjects : Dictionary<string, cMsGraphResultFileObject>
|
|
{
|
|
public cMsGraphCollectionFileObjects() { }
|
|
public cMsGraphCollectionFileObjects(int n) : base(n) { }
|
|
|
|
public void Add(cMsGraphResultFileObject FileObject)
|
|
{
|
|
if (!this.ContainsKey(FileObject.ID))
|
|
this.Add(FileObject.ID, FileObject);
|
|
}
|
|
}
|
|
|
|
public class cMsGraphResultChannelRoot : cMsGraphResultBase
|
|
{
|
|
public cMsGraphResultChannel Channel { get; private set; } = null;
|
|
public cMsGraphResultDrive Drive { get; private set; } = null;
|
|
|
|
public string DriveID { get; private set; } = null;
|
|
|
|
public cMsGraphResultChannelRoot(cMsGraphResultChannel Channel, cMsGraphResultBase Result) : base(Result)
|
|
{
|
|
this.Channel = Channel;
|
|
try
|
|
{
|
|
if (Result.Result.TryGetValue("parentReference", out JToken JT1))
|
|
{
|
|
var pR = Result.Result.parentReference;
|
|
if (pR.TryGetValue("driveId", out JToken JT2))
|
|
{
|
|
DriveID = pR.driveId;
|
|
}
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
}
|
|
}
|
|
|
|
public async Task<bool> ResolveDrive(cMsGraphSharepoint SP)
|
|
{
|
|
if (string.IsNullOrEmpty(DriveID))
|
|
return false;
|
|
|
|
Drive = await SP.RequestDriveInfo(DriveID);
|
|
|
|
return Drive != null;
|
|
}
|
|
|
|
}
|
|
}
|