public ActionResult Featured(int maxCount = 3)
{
using (var clientContext = HttpContext.GetUserClientContextForSPHost()) {
ViewBag.SPHostUrl = HttpContext.Request.QueryString["SPHostUrl"];
var caml = new CamlQuery()
{
ViewXml = CAML.ViewQuery(
CAML.Where(
CAML.And(
CAML.Geq(
CAML.FieldValue(Event.FIELD_DATE, "Date", CAML.Today())
),
CAML.Eq(
CAML.FieldValue(Event.FIELD_CATEGORY, "Text", "Featured")
)
)
),
CAML.OrderBy(new OrderByField(Event.FIELD_DATE)),
rowLimit: maxCount)
};
var list = clientContext.Web.Lists.GetByTitle(ListDetails.EventsListName);
clientContext.Load(list);
clientContext.ExecuteQuery();
var items = list.GetItems(caml);
clientContext.Load(items);
clientContext.ExecuteQuery();
var result = items.Cast <ListItem>()
.Select(i => new Event(i)).ToList();
return(View(result));
}
}
public void Test()
{
var caml = CAML.Where()
.UserField("AssignedTo").EqualToCurrentUser()
.Or()
.UserField("AssignedTo").IsInCurrentUserGroups()
.GroupBy("Category")
.OrderBy("Priority").ThenBy("Title")
.ToString();
string expected = @"<Where>
<Or>
<Eq><FieldRef Name=""AssignedTo"" LookupId=""True"" /><Value Type=""Integer""><UserID /></Value></Eq>
<Membership Type=""CurrentUserGroups""><FieldRef Name=""AssignedTo"" /></Membership>
</Or>
</Where>
<GroupBy>
<FieldRef Name=""Category"" />
</GroupBy>
<OrderBy>
<FieldRef Name=""Priority"" /><FieldRef Name=""Title"" />
</OrderBy>";
Assert.AreEqual(Beautify.Xml(expected), Beautify.Xml(caml));
}
public void Test()
{
var caml = CAML.Where()
.LookupField("Category").Id().In(new int[] { 2, 3, 10 })
.And()
.DateField("ExpirationDate").GreaterThan(CamlValues.Now)
.OrderBy("ExpirationDate")
.ToString();
string expected = @"<Where>
<And>
<In>
<FieldRef Name=""Category"" LookupId=""True"" />
<Values>
<Value Type=""Integer"">2</Value>
<Value Type=""Integer"">3</Value>
<Value Type=""Integer"">10</Value>
</Values>
</In>
<Gt>
<FieldRef Name=""ExpirationDate"" />
<Value Type=""DateTime"">
<Now />
</Value>
</Gt>
</And>
</Where>
<OrderBy>
<FieldRef Name=""ExpirationDate"" />
</OrderBy>";
Assert.AreEqual(Beautify.Xml(expected), Beautify.Xml(caml));
}
/// <summary>
/// Query the list to retreive the last ID
/// </summary>
/// <param name="onlineLibrary">The List we will query</param>
/// <param name="lastItemModifiedDate">The date of the last modified list item</param>
/// <returns></returns>
public static int QueryLastItemId(this List onlineLibrary, Nullable <DateTime> lastItemModifiedDate = null)
{
var returnId = 0;
var camlFieldRefs = new string[] { "ID", "Created", "Modified", };
var camlViewClause = CAML.ViewFields(camlFieldRefs.Select(s => CAML.FieldRef(s)).ToArray());
var camlQuery = new CamlQuery()
{
ViewXml = CAML.ViewQuery(
ViewScope.RecursiveAll,
string.Empty,
CAML.OrderBy(new OrderByField("ID", false)),
camlViewClause,
1)
};
ListItemCollectionPosition itemPosition = null;
while (true)
{
camlQuery.ListItemCollectionPosition = itemPosition;
var spListItems = onlineLibrary.GetItems(camlQuery);
onlineLibrary.Context.Load(spListItems, lti => lti.ListItemCollectionPosition);
onlineLibrary.Context.ExecuteQueryRetry();
itemPosition = spListItems.ListItemCollectionPosition;
if (spListItems.Any())
{
if (lastItemModifiedDate.HasValue)
{
foreach (var item in spListItems)
{
var itemModified = item.RetrieveListItemValue("Modified").ToNullableDatetime();
if (itemModified == lastItemModifiedDate)
{
returnId = item.Id;
break;
}
}
}
else
{
returnId = spListItems.OrderByDescending(ob => ob.Id).FirstOrDefault().Id;
}
if (returnId > 0)
{
// Found the item ID that matches the specified date - return it
break;
}
}
if (itemPosition == null)
{
break;
}
}
return(returnId);
}
public void Test()
{
string caml = CAML.Where()
.Any(
CAML.Expression().TextField("Email").EqualTo("*****@*****.**"),
CAML.Expression().TextField("Email").EqualTo("*****@*****.**"),
CAML.Expression().TextField("Title").BeginsWith("[Google]"),
CAML.Expression().TextField("Content").Contains("Google")
)
.ToString();
string expected = @"<Where>
<Or>
<Eq><FieldRef Name=""Email"" /><Value Type=""Text"">[email protected]</Value></Eq>
<Or>
<Eq><FieldRef Name=""Email"" /><Value Type=""Text"">[email protected]</Value></Eq>
<Or>
<BeginsWith><FieldRef Name=""Title"" /><Value Type=""Text"">[Google]</Value></BeginsWith>
<Contains><FieldRef Name=""Content"" /><Value Type=""Text"">Google</Value></Contains>
</Or>
</Or>
</Or>
</Where>";
Assert.AreEqual(Beautify.Xml(expected), Beautify.Xml(caml));
}
public void Test()
{
var caml = CAML
.View(new string[] { "Category" }, (AggregationType.Count, "ID"), (AggregationType.Sum, "Amount"))
.Query()
.GroupBy("Category", true, 100)
.ToString();
string expected = @"<View>
<ViewFields>
<FieldRef Name=""Category"" />
</ViewFields>
<Aggregations Value=""On"">
<FieldRef Name=""ID"" Type=""COUNT"" />
<FieldRef Name=""Amount"" Type=""SUM"" />
</Aggregations>
<Query>
<GroupBy Collapse=""TRUE"" GroupLimit=""100"">
<FieldRef Name=""Category"" />
</GroupBy>
</Query>
</View>";
Assert.AreEqual(Beautify.Xml(expected), Beautify.Xml(caml));
}
public void Test()
{
var rawQuery = @"<View Scope=""RecursiveAll"">
<Query>
<Where>
<IsNotNull>
<FieldRef Name=""ID"" />
</IsNotNull>
</Where>
</Query>
</View>";
var caml = CAML.FromXml(rawQuery).ModifyWhere().AppendAnd().TextField("Title").IsNotNull().ToString();
string expected = @"<View Scope=""RecursiveAll"">
<Query>
<Where>
<And>
<IsNotNull>
<FieldRef Name=""ID"" />
</IsNotNull>
<IsNotNull>
<FieldRef Name=""Title"" />
</IsNotNull>
</And>
</Where>
</Query>
</View>";
Assert.AreEqual(Beautify.Xml(expected), Beautify.Xml(caml));
}
/// <summary>
/// Retreive file from the specified folder
/// </summary>
/// <param name="onlineLibrary"></param>
/// <param name="destinationFolder"></param>
/// <param name="onlineFileName"></param>
/// <returns></returns>
public static ListItem GetFileInFolder(this List onlineLibrary, Folder destinationFolder, string onlineFileName)
{
destinationFolder.Context.Load(destinationFolder, afold => afold.ServerRelativeUrl);
destinationFolder.Context.ExecuteQuery();
var relativeUrl = destinationFolder.ServerRelativeUrl;
var context = destinationFolder.Context;
try
{
CamlQuery camlQuery = new CamlQuery();
var camlAndValue = CAML.And(
CAML.Eq(CAML.FieldValue("LinkFilename", FieldType.Text.ToString("f"), onlineFileName)),
CAML.Eq(CAML.FieldValue("FileDirRef", FieldType.Text.ToString("f"), relativeUrl)));
camlQuery.ViewXml = CAML.ViewQuery(ViewScope.RecursiveAll,
CAML.Where(camlAndValue),
string.Empty,
CAML.ViewFields(CAML.FieldRef("Title")),
5);
ListItemCollection listItems = onlineLibrary.GetItems(camlQuery);
context.Load(listItems);
context.ExecuteQuery();
if (listItems.Count() > 0)
{
var newItem = listItems.FirstOrDefault();
return(newItem);
}
}
catch (Exception ex)
{
System.Diagnostics.Trace.TraceError("Failed to retrieve file {0} MSG:{1}", onlineFileName, ex.Message);
}
return(null);
}
public ActionResult Index(string category = "")
{
var spContext = SharePointContextProvider.Current.GetSharePointContext(HttpContext);
using (var clientContext = HttpContext.GetUserClientContextForSPHost()) {
ViewBag.SPHostUrl = spContext.SPHostUrl;
ViewBag.Category = category;
var list = clientContext.Web.GetListByTitle(ListDetails.EventsListName);
var categoryQuery = string.Empty;
if (!string.IsNullOrEmpty(category))
{
categoryQuery = CAML.Where(CAML.Eq(CAML.FieldValue(Event.FIELD_CATEGORY, "Text", category)));
}
var orderByQuery = CAML.OrderBy(new OrderByField("Title"));
var caml = new CamlQuery()
{
ViewXml = CAML.ViewQuery(categoryQuery, orderByQuery, rowLimit: 50)
};
var events = list.GetItems(caml);
clientContext.Load(events);
clientContext.ExecuteQuery();
var eventsList = events.Cast <ListItem>().Select(item => new Event(item)).ToList();
return(View(eventsList));
}
}
public void OrderBy_SendManyFieldRefsInOneString_DoesNotThrow()
{
const string orderByString = @"<FieldRef Name=""ID1"" /><FieldRef Name=""ID2"" /><FieldRef Name=""ID3"" />";
var correctResult = $"<OrderBy>{orderByString}</OrderBy>";
var res = CAML.OrderBy(orderByString);
Assert.AreEqual(correctResult, res);
}
internal BeginsWithAndContains(CAML camlBuilder, Predicates predicate, Guid fieldId, string value)
{
if (predicate != Predicates.Contains || predicate != Predicates.BeginsWith)
throw new ArgumentException("contains");
_camlBuilder = camlBuilder;
_predicate = predicate;
_fieldId = fieldId;
_value = value;
}
public void Tag_WithChildXmlElement_ReturnCorrectStringValue()
{
var childTag = CAML.Tag(TestData.TagName, TestData.Value);
var parentTag = CAML.Base.Tag(TestData.TagName, childTag, null);
var parentTagAsString = parentTag.ToString(SaveOptions.DisableFormatting);
Assert.AreEqual(
$@"<{TestData.TagName}><{TestData.TagName}>{TestData.Value}</{TestData.TagName}></{TestData.TagName}>",
parentTagAsString);
}
public void Test()
{
var caml = CAML.Where().DateTimeField("Created").GreaterThan(new DateTime(2013, 1, 1, 0, 0, 0, DateTimeKind.Utc)).ToString();
string expected = @"<Where>
<Gt>
<FieldRef Name=""Created"" />
<Value IncludeTimeValue=""True"" Type=""DateTime"">2013-01-01T00:00:00.000Z</Value>
</Gt>
</Where>";
Assert.AreEqual(Beautify.Xml(expected), Beautify.Xml(caml));
}
public ActionResult Index(int offset = 0)
{
using (var clientContext = HttpContext.GetUserClientContextForSPHost()) {
var list = clientContext.Web.GetListByTitle(ListDetails.EventsListName);
var caml = new CamlQuery()
{
ViewXml = CAML.ViewQuery()
};
var events = list.GetItems(caml);
clientContext.ExecuteQuery();
var eventsList = events.Cast <ListItem>().Select(item => new Event(item)).ToList();
return(View(eventsList));
}
}
/// <summary>
/// Execute the cmdlet
/// </summary>
public override void ExecuteCmdlet()
{
base.ExecuteCmdlet();
Collection <PSObject> results = new Collection <PSObject>();
var _listSites = LibraryName.GetList(this.ClientContext.Web);
ListItemCollectionPosition itemPosition = null;
try
{
while (true)
{
CamlQuery camlQuery = new CamlQuery
{
ListItemCollectionPosition = itemPosition,
ViewXml = CAML.ViewQuery(ViewScope.RecursiveAll, string.Empty, string.Empty, CAML.ViewFields(CAML.FieldRef("Title")), 50)
};
ListItemCollection listItems = _listSites.GetItems(camlQuery);
this.ClientContext.Load(listItems);
this.ClientContext.ExecuteQueryRetry();
itemPosition = listItems.ListItemCollectionPosition;
foreach (var rbiItem in listItems)
{
LogVerbose("Title: {0}; Item ID: {1}", rbiItem["Title"], rbiItem.Id);
var newitem = new
{
Title = rbiItem["Title"],
Id = rbiItem.Id
};
var ps = PSObject.AsPSObject(newitem);
results.Add(ps);
}
if (itemPosition == null)
{
break;
}
}
}
catch (Exception ex)
{
LogError(ex, "Failed to retrieve recycle bin collection");
}
WriteObject(results, true);
}
/// <summary>
/// Will evaluate the Library/List and if the list has reached the threshold it will produce SAFE queries
/// </summary>
/// <param name="onlineLibrary">The list to query</param>
/// <param name="camlStatement">A base CAML query upon which the threshold query will be constructed</param>
/// <returns>A collection of CAML queries NOT including WHERE</returns>
public static List <string> SafeCamlClauseFromThreshold(this List onlineLibrary, string camlStatement = null, int?defaultLastItemId = default(int?))
{
var camlQueries = new List <string>();
onlineLibrary.EnsureProperties(olp => olp.ItemCount, olp => olp.LastItemModifiedDate, olp => olp.LastItemUserModifiedDate);
// we have reached a threshold and need to parse based on other criteria
var itemCount = onlineLibrary.ItemCount;
if (itemCount > 5000)
{
var lastItemId = (defaultLastItemId.HasValue) ? defaultLastItemId.Value : onlineLibrary.QueryLastItemId(onlineLibrary.LastItemModifiedDate);
var startIdx = 0;
var incrementor = 1000;
for (var idx = startIdx; idx < lastItemId + 1;)
{
var startsWithId = idx + 1;
var endsWithId = (idx + incrementor);
if (endsWithId >= lastItemId)
{
endsWithId = lastItemId + 1;
}
var thresholdEq = new SPThresholdEnumerationModel()
{
StartsWithId = startsWithId,
EndsWithId = endsWithId
};
var camlThresholdClause = thresholdEq.AndClause;
if (!string.IsNullOrEmpty(camlStatement))
{
camlThresholdClause = CAML.And(camlThresholdClause, camlStatement);
}
camlQueries.Add(camlThresholdClause);
idx += incrementor;
}
}
else
{
camlQueries.Add(camlStatement ?? string.Empty);
}
return(camlQueries);
}
public void Tag_ComplicatedQuery_DoesNotThrowXmlException()
{
Assert.DoesNotThrow(() =>
{
var fieldRefId = CAML.FieldRef(BuiltInInternalFieldNames.ID);
var orderByAsCaml = CAML.OrderBy(
CAML.FieldRef(BuiltInInternalFieldNames.ID, CAML.SortType.Ascending)
);
var viewFields = new List <string>
{
BuiltInInternalFieldNames.ID,
BuiltInInternalFieldNames.Title
};
var viewFieldsAsCaml = CAML.ViewFieldsByFieldNames(viewFields.ToArray());
const int maxRowLimit = 1000;
var rowLimitAsCaml = CAML.RowLimit(maxRowLimit);
const int startId = 1;
const int endId = maxRowLimit;
CAML.View(
string.Concat(
CAML.Query(
string.Concat(
CAML.Where(
CAML.And(
CAML.Geq(
fieldRefId,
CAML.Value(startId)
),
CAML.Leq(
fieldRefId,
CAML.Value(endId)
)
)
),
orderByAsCaml
)
),
viewFieldsAsCaml,
rowLimitAsCaml
)
);
});
}
/// <summary>
/// Query the list to retreive the last ID
/// </summary>
/// <param name="onlineLibrary">The List we will query</param>
/// <param name="lastItemModifiedDate">The date of the last modified list item</param>
/// <returns></returns>
public static int QueryLastItemId(this List onlineLibrary, Nullable <DateTime> lastItemModifiedDate = null)
{
var returnId = 0;
var camlFieldRefs = new string[] { "ID", "Created", "Modified", };
var camlViewClause = CAML.ViewFields(camlFieldRefs.Select(s => CAML.FieldRef(s)).ToArray());
var camlQuery = new CamlQuery()
{
ViewXml = CAML.ViewQuery(string.Empty, CAML.OrderBy(new OrderByField("Modified", false)), 10)
};
if (!lastItemModifiedDate.HasValue)
{
onlineLibrary.EnsureProperties(olp => olp.LastItemModifiedDate, olp => olp.LastItemUserModifiedDate);
lastItemModifiedDate = onlineLibrary.LastItemModifiedDate;
}
ListItemCollectionPosition ListItemCollectionPosition = null;
while (true)
{
camlQuery.ListItemCollectionPosition = ListItemCollectionPosition;
var spListItems = onlineLibrary.GetItems(camlQuery);
onlineLibrary.Context.Load(spListItems, lti => lti.ListItemCollectionPosition);
onlineLibrary.Context.ExecuteQueryRetry();
ListItemCollectionPosition = spListItems.ListItemCollectionPosition;
if (spListItems.Any())
{
foreach (var item in spListItems)
{
var itemModified = item.RetrieveListItemValue("Modified").ToDateTime();
System.Diagnostics.Trace.TraceInformation("Item {0} Modified {1} IS MATCH:{2}", item.Id, itemModified, (itemModified == lastItemModifiedDate));
}
returnId = spListItems.OrderByDescending(ob => ob.Id).FirstOrDefault().Id;
break;
}
if (ListItemCollectionPosition == null)
{
break;
}
}
return(returnId);
}
public void Test()
{
var caml = CAML.Where().CounterField("ID").In(new int[] { 1, 2, 3 }).ToString();
string expected = @"<Where>
<In>
<FieldRef Name=""ID"" />
<Values>
<Value Type=""Counter"">1</Value>
<Value Type=""Counter"">2</Value>
<Value Type=""Counter"">3</Value>
</Values>
</In>
</Where>";
Assert.AreEqual(Beautify.Xml(expected), Beautify.Xml(caml));
}
public void Test()
{
var caml = CAML
.View()
.Query()
.OrderBy("ID")
.ToString();
string expected = @"<View>
<Query>
<OrderBy>
<FieldRef Name=""ID"" />
</OrderBy>
</Query>
</View>";
Assert.AreEqual(Beautify.Xml(expected), Beautify.Xml(caml));
}
public void Test()
{
var caml = CAML.Expression()
.All(
CAML.Expression().DateField("BroadcastExpires").GreaterThanOrEqualTo(CamlValues.Today),
CAML.Expression().Any(
CAML.Expression().UserField("BroadcastTo").IsInCurrentUserGroups(),
CAML.Expression().UserField("BroadcastTo").EqualToCurrentUser()
),
CAML.Expression().DateRangesOverlap(DateRangesOverlapType.Year, new DateTime().ToUniversalTime().ToString("yyyy-MM-ddTHH:mm:ssZ"))
)
.ToString();
string expected = @"<And>
<Geq>
<FieldRef Name=""BroadcastExpires"" />
<Value Type=""DateTime"">
<Today />
</Value>
</Geq>
<And>
<Or>
<Membership Type=""CurrentUserGroups"">
<FieldRef Name=""BroadcastTo"" />
</Membership>
<Eq>
<FieldRef Name=""BroadcastTo"" LookupId=""True"" />
<Value Type=""Integer""><UserID /></Value>
</Eq>
</Or>
<DateRangesOverlap>
<FieldRef Name=""EventDate"" />
<FieldRef Name=""EndDate"" />
<FieldRef Name=""RecurrenceID"" />
<Value Type=""DateTime"">
<Year />
</Value>
</DateRangesOverlap>
</And>
</And>";
Assert.AreEqual(Beautify.Xml(expected), Beautify.Xml(caml));
}
public void Test()
{
var expression = CAML.Expression().BooleanField("Enabled").IsTrue();
var caml = CAML.View().Query().Where().All(expression).OrderBy("Priority").ToString();
string expected = @"<View>
<Query>
<Where>
<Eq><FieldRef Name=""Enabled"" /><Value Type=""Integer"">1</Value></Eq>
</Where>
<OrderBy>
<FieldRef Name=""Priority"" />
</OrderBy>
</Query>
</View>";
Assert.AreEqual(Beautify.Xml(expected), Beautify.Xml(caml));
}
public void Test()
{
var caml = CAML
.View()
.Scope(ViewScope.RecursiveAll)
.Query()
.Where().NumberField("ID").IsNotNull()
.ToString();
string expected = @"<View Scope=""RecursiveAll"">
<Query>
<Where>
<IsNotNull>
<FieldRef Name=""ID"" />
</IsNotNull>
</Where>
</Query>
</View>";
Assert.AreEqual(Beautify.Xml(expected), Beautify.Xml(caml));
}
/// <summary>
/// Returns the parent item ID
/// </summary>
/// <param name="cContext"></param>
/// <param name="ItemName"></param>
/// <param name="ParentListName"></param>
/// <returns></returns>
internal int GetParentItemID(ClientContext cContext, string ItemName, string ParentListName)
{
int nReturn = -1;
try
{
LogVerbose("Start GetParentItemID");
Web wWeb = cContext.Web;
List lParentList = cContext.Web.Lists.GetByTitle(ParentListName);
CamlQuery camlQuery = new CamlQuery
{
ViewXml = CAML.Where(CAML.Eq(CAML.FieldValue("Title", FieldType.Text.ToString("f"), ItemName)))
};
ListItemCollection collListItem = lParentList.GetItems(camlQuery);
cContext.Load(collListItem);
cContext.ExecuteQuery();
foreach (ListItem oListItem in collListItem)
{
if (oListItem["Title"].ToString() == ItemName)
{
nReturn = oListItem.Id;
break;
}
}
LogVerbose("Complete GetParentItemID");
}
catch (Exception ex)
{
LogError(ex, ex.Message);
}
return(nReturn);
}
public void Test()
{
var rawQuery = @"<View Scope=""RecursiveAll"">
<Query>
<Where>
<Eq>
<FieldRef Name=""ID"" />
<Value Type=""Number"">10</Value>
</Eq>
</Where>
<OrderBy>
<FieldRef Name=""Date"" />
</OrderBy>
</Query>
</View>";
var caml = CAML.FromXml(rawQuery).ModifyWhere().AppendOr().TextField("Title").Contains("Summer").ToString();
string expected = @"<View Scope=""RecursiveAll"">
<Query>
<OrderBy>
<FieldRef Name=""Date"" />
</OrderBy>
<Where>
<Or>
<Eq>
<FieldRef Name=""ID"" />
<Value Type=""Number"">10</Value>
</Eq>
<Contains>
<FieldRef Name=""Title"" />
<Value Type=""Text"">Summer</Value>
</Contains>
</Or>
</Where>
</Query>
</View>";
Assert.AreEqual(Beautify.Xml(expected), Beautify.Xml(caml));
}
public void Test()
{
var caml = CAML
.View(new string[] { "Title", "Country", "Population" })
.LeftJoin("Country", "Country").Select("y4r6", "Population")
.Query()
.Where().NumberField("Population").LessThan(10)
.ToString();
string expected = @"<View>
<ViewFields>
<FieldRef Name=""Title"" />
<FieldRef Name=""Country"" />
<FieldRef Name=""Population"" />
</ViewFields>
<Joins>
<Join Type=""LEFT"" ListAlias=""Country"">
<Eq>
<FieldRef Name=""Country"" RefType=""ID"" />
<FieldRef Name=""ID"" List=""Country"" />
</Eq>
</Join>
</Joins>
<ProjectedFields>
<Field ShowField=""y4r6"" Type=""Lookup"" Name=""Population"" List=""Country"" />
</ProjectedFields>
<Query>
<Where>
<Lt>
<FieldRef Name=""Population"" />
<Value Type=""Number"">10</Value>
</Lt>
</Where>
</Query>
</View>";
Assert.AreEqual(Beautify.Xml(expected), Beautify.Xml(caml));
}
public void Test()
{
var caml = CAML.Where()
.All(
CAML.Expression().All(
CAML.Expression().BooleanField("Enabled").IsTrue(),
CAML.Expression().UserMultiField("TargetAudience").IncludesSuchItemThat().ValueAsText().EqualTo("55").Or().UserMultiField("TargetAudience").IncludesSuchItemThat().ValueAsText().EqualTo("66")
),
CAML.Expression().Any(
CAML.Expression().TextField("NotificationScope").EqualTo("77"),
CAML.Expression().TextField("NotificationScope").EqualTo("88").And().TextField("ScopeWebRelativeUrl").EqualTo("99")
)
)
.ToString();
string expected = @"<Where>
<And>
<And>
<Eq><FieldRef Name=""Enabled"" /><Value Type=""Integer"">1</Value></Eq>
<Or>
<Eq><FieldRef Name=""TargetAudience"" /><Value Type=""Text"">55</Value></Eq>
<Eq><FieldRef Name=""TargetAudience"" /><Value Type=""Text"">66</Value></Eq>
</Or>
</And>
<Or>
<Eq><FieldRef Name=""NotificationScope"" /><Value Type=""Text"">77</Value></Eq>
<And>
<Eq><FieldRef Name=""NotificationScope"" /><Value Type=""Text"">88</Value></Eq>
<Eq><FieldRef Name=""ScopeWebRelativeUrl"" /><Value Type=""Text"">99</Value></Eq>
</And>
</Or>
</And>
</Where>";
Assert.AreEqual(Beautify.Xml(expected), Beautify.Xml(caml));
}
/// <summary>
/// Process the request
/// </summary>
public override void ExecuteCmdlet()
{
base.ExecuteCmdlet();
siteColumns = new List <SPFieldDefinitionModel>();
try
{
//Load list
var siteUrl = this.ClientContext.Url;
var listInSite = this.ClientContext.Web.Lists.GetByTitle(ListTitle);
this.ClientContext.Load(listInSite);
this.ClientContext.ExecuteQuery();
//#TODO: Provision datamigrated column for holder
var camlWhereClause = CAML.Neq(CAML.FieldValue("DataMigrated", "Integer", "1"));
var camlViewFields = CAML.ViewFields((new string[] { "Modified", "", "", "Id" }).Select(s => CAML.FieldRef(s)).ToArray());
// get site and query the list for approved requests
ListItemCollectionPosition ListItemCollectionPosition = null;
var camlQuery = new CamlQuery()
{
ViewXml = CAML.ViewQuery(ViewScope.RecursiveAll, CAML.Where(camlWhereClause), string.Empty, camlViewFields, 50)
};
var output = new List <object>();
while (true)
{
camlQuery.ListItemCollectionPosition = ListItemCollectionPosition;
var spListItems = listInSite.GetItems(camlQuery);
this.ClientContext.Load(spListItems, lti => lti.ListItemCollectionPosition,
lti => lti.IncludeWithDefaultProperties(lnc => lnc.Id, lnc => lnc.ContentType));
this.ClientContext.ExecuteQuery();
ListItemCollectionPosition = spListItems.ListItemCollectionPosition;
foreach (var requestItem in spListItems)
{
var requestId = requestItem.Id;
ListItem _item = listInSite.GetItemById(requestId);
ClientContext.Load(_item);
ClientContext.ExecuteQueryRetry();
try
{
output.Add(ProcessListItem(_item));
}
catch (Exception e)
{
LogError(e, "Failed to update list item {0}", e.Message);
}
}
if (ListItemCollectionPosition == null)
{
break;
}
}
LogVerbose("Writing objects to memory stream.");
output.ForEach(s => WriteObject(s));
}
catch (Exception ex)
{
LogError(ex, "Migrate failed for list items MSG:{0}", ex.Message);
}
}
public override void ExecuteCmdlet()
{
base.ExecuteCmdlet();
var paramlistname = List.Title;
var paramviewname = View.Title;
this.ColumnMappings = new List <FieldMappings>();
try
{
var viewlist = ClientContext.Web.GetListByTitle(paramlistname);
ClientContext.Load(viewlist, rcll => rcll.Fields, rcll => rcll.ItemCount, rcll => rcll.ContentTypes, rcll => rcll.BaseType);
ClientContext.Load(viewlist.Views, wv => wv.Include(wvi => wvi.Title, wvi => wvi.Id, wvi => wvi.ListViewXml, wvi => wvi.ViewFields));
ClientContext.ExecuteQueryRetry();
var viewFieldHeaderHtml = string.Empty;
var view = viewlist.Views.FirstOrDefault(w => w.Title.Trim().Equals(paramviewname, StringComparison.CurrentCultureIgnoreCase));
if (view != null)
{
var doc = XDocument.Parse(view.ListViewXml);
var queryXml = doc.Root.Element(XName.Get("Query"));
var camlFieldXml = doc.Root.Element(XName.Get("ViewFields"));
var queryWhereXml = queryXml.Element(XName.Get("Where"));
var queryGroupByXml = queryXml.Element(XName.Get("GroupBy"));
var queryOrderXml = queryXml.Element(XName.Get("OrderBy"));
var queryViewCaml = ((camlFieldXml != null) ? camlFieldXml.ToString() : string.Empty);
var queryWhereCaml = ((queryWhereXml != null) ? queryWhereXml.ToString() : string.Empty);
var queryOrderCaml = ((queryOrderXml != null) ? queryOrderXml.ToString() : string.Empty);
var viewFields = new List <string>()
{
"ContentTypeId", "FileRef", "FileDirRef", "FileLeafRef"
};
if (viewlist.BaseType == BaseType.GenericList)
{
viewFields.AddRange(new string[] { ConstantsListFields.Field_LinkTitle, ConstantsListFields.Field_LinkTitleNoMenu });
}
if (viewlist.BaseType == BaseType.DocumentLibrary)
{
viewFields.AddRange(new string[] { ConstantsLibraryFields.Field_LinkFilename, ConstantsLibraryFields.Field_LinkFilenameNoMenu });
}
foreach (var xnode in camlFieldXml.Descendants())
{
var attributeValue = xnode.Attribute(XName.Get("Name"));
var fe = attributeValue.Value;
if (fe == "ContentType")
{
fe = "ContentTypeId";
}
if (!viewFields.Any(vf => vf == fe))
{
viewFields.Add(fe);
}
}
// lets override the view field XML with some additional columns
queryViewCaml = CAML.ViewFields(viewFields.Select(s => CAML.FieldRef(s)).ToArray());
var viewFieldsHeader = "<tr>";
var viewFieldsHeaderIdx = 0;
view.ViewFields.ToList().ForEach(fe =>
{
var fieldDisplayName = viewlist.Fields.FirstOrDefault(fod => fod.InternalName == fe);
ColumnMappings.Add(new FieldMappings()
{
ColumnInternalName = fieldDisplayName.InternalName,
ColumnMandatory = fieldDisplayName.Required,
ColumnType = fieldDisplayName.FieldTypeKind
});
viewFieldsHeader += string.Format("<th>{0}</th>", (fieldDisplayName == null ? fe : fieldDisplayName.Title));
viewFieldsHeaderIdx++;
});
viewFieldsHeader += "</tr>";
var innerGroupName = string.Empty;
var hasGroupStrategy = false;
if (queryGroupByXml != null && queryGroupByXml.HasElements)
{
queryWhereCaml = queryGroupByXml.ToString() + queryWhereCaml;
hasGroupStrategy = true;
var innerGroupBy = queryGroupByXml.Elements();
var innerGroupField = innerGroupBy.FirstOrDefault();
innerGroupName = innerGroupField.Attribute(XName.Get("Name")).Value;
}
var camlQueryXml = CAML.ViewQuery(ViewScope.RecursiveAll, queryWhereCaml, queryOrderCaml, queryViewCaml, 500);
ListItemCollectionPosition camlListItemCollectionPosition = null;
var camlQuery = new CamlQuery();
camlQuery.ViewXml = camlQueryXml;
var previousgroupname = "zzzzzzzzzheader";
var htmltoemail = new StringBuilder();
htmltoemail.Append("<table>");
if (!hasGroupStrategy)
{
htmltoemail.Append(viewFieldsHeader);
}
while (true)
{
camlQuery.ListItemCollectionPosition = camlListItemCollectionPosition;
var spListItems = viewlist.GetItems(camlQuery);
this.ClientContext.Load(spListItems, lti => lti.ListItemCollectionPosition);
this.ClientContext.ExecuteQueryRetry();
camlListItemCollectionPosition = spListItems.ListItemCollectionPosition;
foreach (var ittpItem in spListItems)
{
LogVerbose("Item {0}", ittpItem.Id);
if (hasGroupStrategy)
{
var currentgroupname = ittpItem.RetrieveListItemValue(innerGroupName).Trim();
if (previousgroupname != currentgroupname)
{
htmltoemail.AppendFormat("<tr><th colspan='{0}' style='text-align:center;background-color:blue;color:white'>{1}</th></tr>", viewFieldsHeaderIdx, currentgroupname);
htmltoemail.Append(viewFieldsHeader);
previousgroupname = currentgroupname;
}
}
var htmlrow = "<tr>";
view.ViewFields.ToList().ForEach(fe =>
{
if (fe == "ContentType")
{
fe = "ContentTypeId";
}
var htmlrowvalue = string.Empty;
try
{
var c = ColumnMappings.FirstOrDefault(f => f.ColumnInternalName == fe);
if (c != null && c.ColumnType == FieldType.Lookup)
{
var res = ittpItem.RetrieveListItemValueAsLookup(fe);
htmlrowvalue = res.ToLookupValue();
}
else if (c != null && c.ColumnType == FieldType.User)
{
var res = ittpItem.RetrieveListItemUserValue(fe);
htmlrowvalue = res.ToUserValue();
}
else
{
htmlrowvalue = ittpItem.RetrieveListItemValue(fe);
}
}
catch (Exception fex) {
LogWarning("Failed to retreive {0} msg => {1}", fe, fex.Message);
}
finally { }
htmlrow += string.Format("<td>{0}</td>", htmlrowvalue);
});
htmlrow += "</tr>";
htmltoemail.Append(htmlrow);
}
if (camlListItemCollectionPosition == null)
{
break;
}
}
htmltoemail.Append("</table>");
var properties = new EmailProperties
{
To = SendTo,
Subject = $"HTML from Email List ${List.Title}",
Body = string.Format("<div>{0}</div>", htmltoemail.ToString())
};
Microsoft.SharePoint.Client.Utilities.Utility.SendEmail(this.ClientContext, properties);
this.ClientContext.ExecuteQueryRetry();
}
}
catch (Exception fex)
{
LogError(fex, "Failed to parse view and produce HTML report");
}
}
public override void ExecuteCmdlet()
{
base.ExecuteCmdlet();
var fields = new string[]
{
"_dlc_DocId", "_dlc_DocIdUrl", "Modified", "Editor", "ServerRedirectedEmbedUri", "FileRef", "Title"
};
var fieldsXml = CAML.ViewFields(fields.Select(s => CAML.FieldRef(s)).ToArray());
var onlineLibrary = List.GetList(this.ClientContext.Web);
foreach (var csvitem in Items)
{
var ItemId = csvitem.Id;
try
{
var item = onlineLibrary.GetItemById(ItemId);
this.ClientContext.Load(item);
this.ClientContext.ExecuteQueryRetry();
if (item == null)
{
LogWarning("Failed to retreive listitem ID {0}", ItemId);
}
else
{
var docId = item.RetrieveListItemValue("_dlc_DocId");
var docIdUrl = item.RetrieveListItemValueAsHyperlink("_dlc_DocIdUrl");
var modified = item.RetrieveListItemValue("Modified");
var editor = item.RetrieveListItemUserValue("Editor");
var redirectEmbeddedUrl = item.RetrieveListItemValue("ServerRedirectedEmbedUri");
var fileRef = item.RetrieveListItemValue("FileRef");
var title = item.RetrieveListItemValue("Title");
LogVerbose("[PRE UPDATE] ==> DocId {0} DocIdUrl {1}, Modified {2} Editor {3}, Embedded Url {4}, FileRef {5}", docId, (docIdUrl != null ? docIdUrl.Url : ""), modified, editor.Email, redirectEmbeddedUrl, fileRef);
if (docIdUrl != null && docIdUrl.Url.IndexOf(PartialUrl, StringComparison.InvariantCultureIgnoreCase) > -1)
{
item["_dlc_DocId"] = null;
item["_dlc_DocIdUrl"] = null;
item["Modified"] = modified;
item["Editor"] = editor;
// January 5, 2015 8:53:42 PM [email protected]
//item["Modified"] = DateTime.Parse("1/5/2015 8:53:42 PM");
//item["Editor"] = new FieldUserValue() { LookupId = user.Id };
item.SystemUpdate();
this.ClientContext.ExecuteQueryRetry();
item = onlineLibrary.GetItemById(ItemId);
this.ClientContext.Load(item);
this.ClientContext.ExecuteQueryRetry();
docId = item.RetrieveListItemValue("_dlc_DocId");
docIdUrl = item.RetrieveListItemValueAsHyperlink("_dlc_DocIdUrl");
modified = item.RetrieveListItemValue("Modified");
editor = item.RetrieveListItemUserValue("Editor");
redirectEmbeddedUrl = item.RetrieveListItemValue("ServerRedirectedEmbedUri");
fileRef = item.RetrieveListItemValue("FileRef");
title = item.RetrieveListItemValue("Title");
LogVerbose("[POST UPDATE] ==> DocId {0} DocIdUrl {1}, Modified {2} Editor {3}, Embedded Url {4}, FileRef {5}", docId, (docIdUrl != null ? docIdUrl.Url : ""), modified, editor.Email, redirectEmbeddedUrl, fileRef);
}
else
{
LogWarning("Item ID {0} has a url which does not need to be updated.", ItemId);
}
}
}
catch (Exception ex)
{
LogWarning("Failed to process list item {0} with message {1}", ItemId, ex.Message);
}
}
}
/// <summary>
/// Retrieves or creates the folder as a ListItem
/// </summary>
/// <param name="onlineLibrary"></param>
/// <param name="destinationFolder"></param>
/// <param name="folderName"></param>
/// <param name="defaultLastItemId"></param>
/// <returns>The listitem as a folder</returns>
public static Folder GetOrCreateFolder(this List onlineLibrary, Folder destinationFolder, string folderName, int?defaultLastItemId = default(int?))
{
destinationFolder.EnsureProperties(afold => afold.ServerRelativeUrl, afold => afold.Folders);
var folderRelativeUrl = destinationFolder.ServerRelativeUrl;
// Remove invalid characters
var trimmedFolder = HelperExtensions.GetCleanDirectory(folderName, string.Empty);
ListItem folderItem = null;
var camlFields = new string[] { "Title", "ContentType", "ID" };
var camlViewFields = CAML.ViewFields(camlFields.Select(s => CAML.FieldRef(s)).ToArray());
var camlClause = CAML.And(
CAML.And(
CAML.Eq(CAML.FieldValue("FileDirRef", FieldType.Text.ToString("f"), folderRelativeUrl)),
CAML.Or(
CAML.Eq(CAML.FieldValue("LinkFilename", FieldType.Text.ToString("f"), trimmedFolder)),
CAML.Eq(CAML.FieldValue("Title", FieldType.Text.ToString("f"), trimmedFolder))
)
)
,
CAML.Eq(CAML.FieldValue("FSObjType", FieldType.Integer.ToString("f"), 1.ToString()))
);
var camlQueries = onlineLibrary.SafeCamlClauseFromThreshold(camlClause, defaultLastItemId);
foreach (var camlAndValue in camlQueries)
{
var camlWhereClause = CAML.Where(camlAndValue);
var camlQuery = new CamlQuery()
{
ViewXml = CAML.ViewQuery(ViewScope.RecursiveAll, camlWhereClause, string.Empty, camlViewFields, 5)
};
var listItems = onlineLibrary.GetItems(camlQuery);
onlineLibrary.Context.Load(listItems);
onlineLibrary.Context.ExecuteQueryRetry();
if (listItems.Count() > 0)
{
folderItem = listItems.FirstOrDefault();
System.Diagnostics.Trace.TraceInformation("Item {0} exists in the destination folder. Skip item creation file.....", folderName);
break;
}
}
;
if (folderItem != null)
{
return(folderItem.Folder);
}
try
{
var info = new ListItemCreationInformation();
info.UnderlyingObjectType = FileSystemObjectType.Folder;
info.LeafName = trimmedFolder;
info.FolderUrl = folderRelativeUrl;
folderItem = onlineLibrary.AddItem(info);
folderItem["Title"] = trimmedFolder;
folderItem.Update();
onlineLibrary.Context.ExecuteQueryRetry();
System.Diagnostics.Trace.TraceInformation("{0} folder Created", trimmedFolder);
return(folderItem.Folder);
}
catch (Exception Ex)
{
System.Diagnostics.Trace.TraceError("Failed to create or get folder for name {0} MSG:{1}", folderName, Ex.Message);
}
return(null);
}
