// Get fields of the content type
public static string GetAllFieldsByContentId(SharepointRequest request)
{
string configJson = string.Empty;
var ctype = request.Type;
string ServerRelativeUrl = Utility.GetRelativeUrl(request.ServerRelativeUrl);
var title = request.Name;
ClientContext clientContext = GetClientContext(request);
using (clientContext)
{
ContentType contentType = clientContext.Web.ContentTypes.GetById(request.ContentTypeId);
clientContext.Load(contentType);
clientContext.ExecuteQuery();
var fields = contentType.Fields;
clientContext.Load(fields, types => types.Include(type => type.Id, type => type.Title,
type => type.TypeDisplayName, type => type.DefaultValue, type => type.TypeAsString,
type => type.InternalName, type => type.Required, type => type.ReadOnlyField,
type => type.StaticName, type => type.Hidden));
clientContext.Load(fields);
clientContext.ExecuteQuery();
List <SharePointField> lFields = new List <SharePointField>();
foreach (var field in fields)
{
if (!field.FromBaseType && field.TypeAsString != FieldTypesConst.FieldLookupMulti && field.InternalName != FieldTypesConst.FieldTaxKeywordHT && field.Group != "_Hidden" && !field.Hidden)
{
if ((field.TypeAsString.ToLower() == FieldTypesConst.FieldDate.ToLower()) || (field.TypeAsString.ToLower() == FieldTypesConst.FieldDateOnly.ToLower()))
{
lFields.Add(GetSpFieldProperties(field, clientContext));
}
}
}
return(JsonHelper.ConvertToJson(lFields));
}
}
public async Task UpdateItem(string list, StorageItem item, CancellationToken cancellationToken)
{
var idConditions = new[] { new EqualCondition(x => x.Id, item.Id) };
var listItems = (await this.GetListItems(list, idConditions, cancellationToken)).ToArray();
this.EnsureSingleItemReturned(listItems);
var existingListItem = listItems.First();
var updateItemUrl = this.GetListItemsUrl(list, false);
updateItemUrl += $"({existingListItem.Id})";
var listItemType = await this.GetListItemType(list, cancellationToken);
var requestData = this.StorageItemToListItemRequest(item, listItemType);
var request = SharepointRequest
.Create(HttpMethod.Post, updateItemUrl)
.WithContent(requestData)
.WithIfMatchHeader()
.WithXHttpMethodHeader("MERGE");
await this.requestExecutor.ExecuteSharepointRequest <SharepointListItem>(request, cancellationToken);
}
// Create SharePoint site context
public static string GetAllContentTypesBySiteUrl(SharepointRequest request)
{
try
{
using (ClientContext context = GetClientContext(request))
{
ContentTypeCollection contentTypeColl = context.Web.ContentTypes;
context.Load(contentTypeColl);
context.ExecuteQuery();
List <SPContentType> contentTypes = new List <SPContentType>();
foreach (ContentType contentType in contentTypeColl)
{
string id = contentType.Id.ToString();
if (contentType.Group != "_Hidden" && !contentType.Hidden && (id.StartsWith(SPDocumentContentType.DocumentContentType) || id.StartsWith(SPDocumentContentType.DocumentSetContentType)))
{
contentTypes.Add(new SPContentType()
{
Id = id,
Name = contentType.Name,
Selected = false
});
}
}
return(JsonHelper.ConvertToJson(contentTypes));
}
}
catch
{
throw;
}
}
private async Task <string> GetListItemType(string list, CancellationToken cancellationToken)
{
var listUrl = $"{this.GetListUrl(list)}?$select=ListItemEntityTypeFullName";
var request = SharepointRequest.Create(HttpMethod.Get, listUrl);
var response = await this.requestExecutor.ExecuteSharepointRequest <SharepointListResponse>(request, cancellationToken);
return(response.ListItemEntityTypeFullName);
}
public static List GetLibraryByContext(SharepointRequest request, ClientContext context)
{
string Url = Utility.GetServerRelativeUrl(request.Url, request.ServerRelativeUrl).Remove(0, 1);
List library = context.Web.GetList(Url);
context.Load(library);
context.ExecuteQuery();
string title = library.Title;
return(library);
}
public async Task <T> ExecuteSharepointRequest <T>(SharepointRequest request, CancellationToken cancellationToken = default(CancellationToken))
{
var response = await this.ExecuteSharepointRequest(request, cancellationToken);
if (!response.IsSuccessStatusCode)
{
throw new HttpRequestException($"Request failed with {response.StatusCode} status code");
}
var content = await response.Content.ReadAsStringAsync();
return(JsonConvert.DeserializeObject <T>(content));
}
public async Task <HttpResponseMessage> ExecuteSharepointRequest(SharepointRequest request, CancellationToken cancellationToken = default(CancellationToken))
{
// To cache access token for several Sharepoint requests in bounds of one request to storage
if (this.accessToken == null)
{
this.accessToken = await this.authTokenService.GetAccessToken(this.configuration.ServerUrl, cancellationToken);
}
request = request
.WithAcceptHeader("application/json;odata=nometadata")
.WithBearerAuthorizationHeader(this.accessToken);
return(await this.httpClient.SendAsync(request.GetHttpRequest(), cancellationToken));
}
public async Task <StorageItem> AddItem(string list, StorageItem item, CancellationToken cancellationToken)
{
var listItemType = await this.GetListItemType(list, cancellationToken);
var requestData = this.StorageItemToListItemRequest(item, listItemType);
var request = SharepointRequest
.Create(HttpMethod.Post, this.GetListItemsUrl(list))
.WithContent(requestData);
var addedItem = await this.requestExecutor.ExecuteSharepointRequest <SharepointListItem>(request, cancellationToken);
return(this.ListItemToStorageItem(addedItem));
}
public string SearchSharepointSite(SharepointRequest request)
{
try
{
if (request == null)
{
throw new Exception("Request cannot be null");
}
return(SPBrowse.SearchSharepointSite(request));
}
catch (Exception ex)
{
_logger.Error("SearchSharepointSite--", ex);
}
return("{}");
}
public string GetAllFieldsByContentId(SharepointRequest request)
{
try
{
if (request == null)
{
throw new Exception("Request cannot be null");
}
return(SPBrowse.GetAllFieldsByContentId(request));
}
catch (Exception ex)
{
_logger.Error("GetAllFieldsByContentId--", ex);
}
return("{}");
}
public static string SearchSharepointSite(SharepointRequest request)
{
string token = request.AccessToken;
string relativeUrl = Utility.GetServerRelativeUrl(request.Url, request.ServerRelativeUrl);
ClientContext clientContext = GetClientContext(request);
using (clientContext)
{
KeywordQuery keywordQuery = new KeywordQuery(clientContext);
keywordQuery.ClientType = "ContentSearchRegular";
keywordQuery.StartRow = 0;
keywordQuery.QueryText = "(Site:" + request.Url + ") AND ((contentclass=STS_Site) AND ((WebTemplate <>POLICYCTR) AND (WebTemplate <>POINTPUBLISHINGHUB) AND (WebTemplate <>POINTPUBLISHINGTOPIC) AND (-SPSiteUrl:personal)))";
StringCollection selectProperties = keywordQuery.SelectProperties;
keywordQuery.TrimDuplicates = true;
keywordQuery.StartRow = 0;
keywordQuery.RowLimit = 50;
keywordQuery.SelectProperties.Add("Title");
keywordQuery.SelectProperties.Add("Path");
keywordQuery.SelectProperties.Add("SiteName");
keywordQuery.SelectProperties.Add("SiteTitle");
keywordQuery.SelectProperties.Add("ContentTypeId");
keywordQuery.SelectProperties.Add("SPSiteUrl");
keywordQuery.SelectProperties.Add("SPWebUrl");
keywordQuery.SelectProperties.Add("Type");
keywordQuery.TrimDuplicates = false;
SearchExecutor searchExecutor = new SearchExecutor(clientContext);
clientContext.ExecutingWebRequest += new EventHandler <WebRequestEventArgs>((s, e) => context_ExecutingWebRequest(s, e, token));
ClientResult <ResultTableCollection> results = searchExecutor.ExecuteQuery(keywordQuery);
clientContext.ExecuteQuery();
List <SharepointRequest> spRequests = new List <SharepointRequest>();
foreach (var resultRow in results.Value[0].ResultRows)
{
SharepointRequest spRequest = new SharepointRequest();
string url = !string.IsNullOrEmpty(Convert.ToString(resultRow["SPSiteUrl"])) ? resultRow["SPSiteUrl"].ToString() : "";
spRequest.Url = url;
spRequest.Name = !string.IsNullOrEmpty(Convert.ToString(resultRow["Title"])) ? resultRow["Title"].ToString() : "";
if (!string.IsNullOrEmpty(Convert.ToString(resultRow["Path"])))
{
Uri uri = new Uri(resultRow["Path"].ToString());
string serverRelativeURL = uri.AbsolutePath;
spRequest.ServerRelativeUrl = serverRelativeURL;
}
spRequests.Add(spRequest);
}
return(JsonHelper.ConvertToJson(spRequests));
}
}
private async Task <IEnumerable <SharepointListItem> > GetListItems(
string list,
IEnumerable <ICondition> conditions,
CancellationToken cancellationToken)
{
var itemsUrl = this.GetListItemsUrl(list);
var conditionsUrlPart = this.conditionsCompiler.CompileConditions(conditions);
if (conditionsUrlPart != null)
{
itemsUrl += $"&{conditionsUrlPart}";
}
var request = SharepointRequest.Create(HttpMethod.Get, itemsUrl);
var response = await this.requestExecutor.ExecuteSharepointRequest <SharepointListItemsResponse>(request, cancellationToken);
return(response.Value);
}
public async Task DeleteItem(string list, string itemId, CancellationToken cancellationToken)
{
var idConditions = new[] { new EqualCondition(x => x.Id, itemId) };
var listItems = (await this.GetListItems(list, idConditions, cancellationToken)).ToArray();
this.EnsureSingleItemReturned(listItems);
var existingListItem = listItems.First();
var deleteItemUrl = this.GetListItemsUrl(list, false);
deleteItemUrl += $"({existingListItem.Id})";
var request = SharepointRequest
.Create(HttpMethod.Post, deleteItemUrl)
.WithIfMatchHeader()
.WithXHttpMethodHeader("DELETE");
await this.requestExecutor.ExecuteSharepointRequest(request, cancellationToken);
}
public static ClientContext GetClientContext(SharepointRequest request)
{
if (!request.ServerRelativeUrl.StartsWith("/"))
{
request.ServerRelativeUrl = "/" + request.ServerRelativeUrl;
}
string locationUrl = $"{request.Url}{Utility.GetRelativeUrl(request.ServerRelativeUrl)}";
Uri locationUri = new Uri(locationUrl);
var t = request.AccessToken;
ClientContext RootContext = new ClientContext(locationUri.Scheme + Uri.SchemeDelimiter + locationUri.Host);
RootContext.ExecutingWebRequest += new EventHandler <WebRequestEventArgs>((s, e) => context_ExecutingWebRequest(s, e, t));
Web web = RootContext.Web;
RootContext.Load(web);
RootContext.ExecuteQuery();
Uri webUrl = Web.WebUrlFromFolderUrlDirect(RootContext, locationUri);
ClientContext clientContext = new ClientContext(webUrl.ToString());
clientContext.ExecutingWebRequest += new EventHandler <WebRequestEventArgs>((s, e) => context_ExecutingWebRequest(s, e, t));
return(clientContext);
}
