/// <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);
}
/// <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 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 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>
/// Process the internals of the CmdLet
/// </summary>
public override void ExecuteCmdlet()
{
base.ExecuteCmdlet();
// Load email notification list
var listInSite = this.ListTitle.GetList(this.ClientContext.Web);
// get site and query the list for pending requests
var fieldNames = new List <string>()
{
"ID"
};
if (ViewFields != null && ViewFields.Length > 0)
{
fieldNames.AddRange(ViewFields);
}
;
var fieldsXml = CAML.ViewFields(fieldNames.Select(s => CAML.FieldRef(s)).ToArray());
var camlWhereClause = string.Empty;
var camlWhereConcat = false;
if (!string.IsNullOrEmpty(this.OverrideCamlQuery))
{
camlWhereConcat = true;
camlWhereClause = this.OverrideCamlQuery;
}
if (StartsWithId > 0)
{
var camlWhereSubClause = CAML.Geq(CAML.FieldValue("ID", FieldType.Number.ToString("f"), StartsWithId.ToString()));
if (camlWhereConcat)
{
// Wrap in an And Clause
camlWhereClause = CAML.And(camlWhereClause, camlWhereSubClause);
}
else
{
camlWhereConcat = true;
camlWhereClause = camlWhereSubClause;
}
}
if (EndsWithId > 0)
{
var camlWhereSubClause = CAML.Leq(CAML.FieldValue("ID", FieldType.Number.ToString("f"), EndsWithId.ToString()));
if (camlWhereConcat)
{
// Wrap in an And Clause
camlWhereClause = CAML.And(camlWhereClause, camlWhereSubClause);
}
else
{
camlWhereConcat = true;
camlWhereClause = camlWhereSubClause;
}
}
if (string.IsNullOrEmpty(camlWhereClause))
{
throw new Exception("Failed to construct a valid CAML Query.");
}
try
{
ListItemCollectionPosition ListItemCollectionPosition = null;
var camlQuery = new CamlQuery()
{
ViewXml = CAML.ViewQuery(ViewScope.RecursiveAll, CAML.Where(camlWhereClause), string.Empty, fieldsXml, 50)
};
var ids = new List <int>();
while (true)
{
camlQuery.ListItemCollectionPosition = ListItemCollectionPosition;
var spListItems = listInSite.GetItems(camlQuery);
this.ClientContext.Load(spListItems);
this.ClientContext.ExecuteQueryRetry();
ListItemCollectionPosition = spListItems.ListItemCollectionPosition;
foreach (var spListItem in spListItems)
{
var s = string.Empty;
LogWarning("ListItem [{0}] will be deleted.", spListItem.Id);
foreach (var fieldName in fieldNames)
{
s += string.Format("...[{0}]==[{1}]...", fieldName, spListItem[fieldName]);
}
LogVerbose("LISTITEM: {0}", s);
ids.Add(spListItem.Id);
}
if (ListItemCollectionPosition == null)
{
break;
}
}
// enumerate the ids to be deleted and process if -WhatIf (not passed)
foreach (var id in ids)
{
if (this.ShouldProcess(string.Format("ListItem [{0}] now being deleted.", id)))
{
var spListItem = listInSite.GetItemById(id);
spListItem.DeleteObject();
listInSite.Update();
this.ClientContext.ExecuteQueryRetry();
}
}
}
catch (Exception ex)
{
LogError(ex, "Failed to query list {0} with message {1}", this.ListTitle, ex.Message);
}
}
/// <summary>
/// Execute the cmdlet
/// </summary>
public override void ExecuteCmdlet()
{
base.ExecuteCmdlet();
// Initialize logging instance with Powershell logger
ITraceLogger logger = new DefaultUsageLogger(LogVerbose, LogWarning, LogError);
// Construct the model
var SiteComponents = new SiteProvisionerModel()
{
Lists = new List <SPListDefinition>()
};
var ctx = this.ClientContext;
var contextWeb = this.ClientContext.Web;
ctx.Load(contextWeb, ctxw => ctxw.ServerRelativeUrl, wctx => wctx.Url, ctxw => ctxw.Id);
ctx.ExecuteQueryRetry();
var _targetList = Identity.GetList(contextWeb, lctx => lctx.ItemCount, lctx => lctx.EnableFolderCreation, lctx => lctx.RootFolder, lctx => lctx.RootFolder.ServerRelativeUrl, lctx => lctx.RootFolder.Folders);
var webUri = new Uri(contextWeb.Url);
// Will query the list to determine the last item id in the list
var lastItemId = _targetList.QueryLastItemId();
logger.LogInformation("List with item count {0} has a last ID of {1}", _targetList.ItemCount, lastItemId);
logger.LogInformation("List has folder creation = {0}", _targetList.EnableFolderCreation);
// store the OOTB standard fields
var ootbCamlFields = new List <string>()
{
"Title", "ID", "Author", "Editor", "Created", "Modified"
};
// Skip these specific fields
var skiptypes = new FieldType[]
{
FieldType.Invalid,
FieldType.Computed,
FieldType.ContentTypeId,
FieldType.Invalid,
FieldType.WorkflowStatus,
FieldType.WorkflowEventType,
FieldType.Threading,
FieldType.ThreadIndex,
FieldType.Recurrence,
FieldType.PageSeparator,
FieldType.OutcomeChoice,
FieldType.CrossProjectLink,
FieldType.ModStat,
FieldType.Error,
FieldType.MaxItems,
FieldType.Attachments
};
// pull a small portion of the list
// wire up temporary array
var sitelists = new List <SPListDefinition>()
{
ctx.GetListDefinition(_targetList, ExpandObjects, logger, skiptypes)
};
if (sitelists.Any())
{
var idx = 0;
// lets add any list with NO lookups first
var nolookups = sitelists.Where(sl => !sl.ListDependency.Any());
nolookups.ToList().ForEach(nolookup =>
{
logger.LogInformation("adding list {0}", nolookup.ListName);
nolookup.ProvisionOrder = idx++;
SiteComponents.Lists.Add(nolookup);
sitelists.Remove(nolookup);
});
// order with first in stack
var haslookups = sitelists.Where(sl => sl.ListDependency.Any()).OrderBy(ob => ob.ListDependency.Count()).ToList();
while (haslookups.Count() > 0)
{
var listPopped = haslookups.FirstOrDefault();
haslookups.Remove(listPopped);
logger.LogInformation("popping list {0}", listPopped.ListName);
if (listPopped.ListDependency.Any(listField => listPopped.ListName.Equals(listField, StringComparison.InvariantCultureIgnoreCase) ||
listPopped.InternalName.Equals(listField, StringComparison.InvariantCultureIgnoreCase)))
{
// the list has a dependency on itself
logger.LogInformation("Adding list {0} with dependency on itself", listPopped.ListName);
listPopped.ProvisionOrder = idx++;
SiteComponents.Lists.Add(listPopped);
}
else if (listPopped.ListDependency.Any(listField =>
!SiteComponents.Lists.Any(sc => sc.ListName.Equals(listField, StringComparison.InvariantCultureIgnoreCase) ||
sc.InternalName.Equals(listField, StringComparison.InvariantCultureIgnoreCase))))
{
// no list definition exists in the collection with the dependent lookup lists
logger.LogWarning("List {0} depends on {1} which do not exist current collection", listPopped.ListName, string.Join(",", listPopped.ListDependency));
foreach (var dependent in listPopped.ListDependency.Where(dlist => !haslookups.Any(hl => hl.ListName == dlist)))
{
var sitelist = contextWeb.GetListByTitle(dependent, lctx => lctx.Id, lctx => lctx.Title, lctx => lctx.RootFolder.ServerRelativeUrl);
var sitelistDefinition = ctx.GetListDefinition(contextWeb, sitelist, true, logger, skiptypes);
haslookups.Add(sitelistDefinition);
}
haslookups.Add(listPopped); // add back to collection
listPopped = null;
}
else
{
logger.LogInformation("Adding list {0} to collection", listPopped.ListName);
listPopped.ProvisionOrder = idx++;
SiteComponents.Lists.Add(listPopped);
}
}
}
foreach (var listDefinition in SiteComponents.Lists.OrderBy(ob => ob.ProvisionOrder))
{
listDefinition.ListItems = new List <SPListItemDefinition>();
var camlFields = new List <string>();
var listTitle = listDefinition.ListName;
var etlList = this.ClientContext.Web.GetListByTitle(listTitle,
lctx => lctx.Id, lctx => lctx.ItemCount, lctx => lctx.EnableFolderCreation, lctx => lctx.RootFolder.ServerRelativeUrl);
if (ExpandObjects)
{
// list fields
var listFields = listDefinition.FieldDefinitions;
if (listFields != null && listFields.Any())
{
var filteredListFields = listFields.Where(lf => !skiptypes.Any(st => lf.FieldTypeKind == st)).ToList();
var notInCamlFields = listFields.Where(listField => !ootbCamlFields.Any(cf => cf.Equals(listField.InternalName, StringComparison.CurrentCultureIgnoreCase)) && !skiptypes.Any(st => listField.FieldTypeKind == st));
foreach (var listField in notInCamlFields)
{
logger.LogInformation("Processing list {0} field {1}", etlList.Title, listField.InternalName);
camlFields.Add(listField.InternalName);
}
}
}
camlFields.AddRange(ootbCamlFields);
var camlViewFields = CAML.ViewFields(camlFields.Select(s => CAML.FieldRef(s)).ToArray());
ListItemCollectionPosition itemPosition = null;
var camlQueries = etlList.SafeCamlClauseFromThreshold(2000, CamlStatement, 0, lastItemId);
foreach (var camlAndValue in camlQueries)
{
itemPosition = null;
var camlWhereClause = (string.IsNullOrEmpty(camlAndValue) ? string.Empty : CAML.Where(camlAndValue));
var camlQuery = new CamlQuery()
{
ViewXml = CAML.ViewQuery(
ViewScope.RecursiveAll,
camlWhereClause,
CAML.OrderBy(new OrderByField("ID")),
camlViewFields,
500)
};
try
{
while (true)
{
logger.LogWarning("CAML Query {0} at position {1}", camlWhereClause, (itemPosition == null ? string.Empty : itemPosition.PagingInfo));
camlQuery.ListItemCollectionPosition = itemPosition;
var listItems = etlList.GetItems(camlQuery);
etlList.Context.Load(listItems);
etlList.Context.ExecuteQueryRetry();
itemPosition = listItems.ListItemCollectionPosition;
foreach (var rbiItem in listItems)
{
var itemId = rbiItem.Id;
var itemTitle = rbiItem.RetrieveListItemValue("Title");
var author = rbiItem.RetrieveListItemUserValue("Author");
var editor = rbiItem.RetrieveListItemUserValue("Editor");
logger.LogInformation("Title: {0}; Item ID: {1}", itemTitle, itemId);
var newitem = new SPListItemDefinition()
{
Id = itemId,
Title = itemTitle,
Created = rbiItem.RetrieveListItemValue("Created").ToNullableDatetime(),
Modified = rbiItem.RetrieveListItemValue("Modified").ToNullableDatetime()
};
if (author != null)
{
newitem.CreatedBy = new SPPrincipalUserDefinition()
{
Email = author.ToUserEmailValue(),
LoginName = author.ToUserValue(),
Id = author.LookupId
};
}
if (editor != null)
{
newitem.ModifiedBy = new SPPrincipalUserDefinition()
{
Email = editor.ToUserEmailValue(),
LoginName = editor.ToUserValue(),
Id = editor.LookupId
};
}
if (ExpandObjects)
{
var fieldValuesToWrite = rbiItem.FieldValues.Where(rfield => !ootbCamlFields.Any(oc => rfield.Key.Equals(oc, StringComparison.CurrentCultureIgnoreCase)));
foreach (var rbiField in fieldValuesToWrite)
{
newitem.ColumnValues.Add(new SPListItemFieldDefinition()
{
FieldName = rbiField.Key,
FieldValue = rbiField.Value
});
}
}
listDefinition.ListItems.Add(newitem);
}
if (itemPosition == null)
{
break;
}
}
}
catch (Exception ex)
{
logger.LogError(ex, "Failed to retrieve list item collection");
}
}
}
WriteObject(SiteComponents);
}
public override void ExecuteCmdlet()
{
base.ExecuteCmdlet();
var SelectedWeb = this.ClientContext.Web;
ilogger = new DefaultUsageLogger(
(string msg, object[] margs) =>
{
LogDebugging(msg, margs);
},
(string msg, object[] margs) =>
{
LogWarning(msg, margs);
},
(Exception ex, string msg, object[] margs) =>
{
LogError(ex, msg, margs);
});
var list = List.GetList(SelectedWeb);
SelectedWeb.Context.Load(list, lctx => lctx.Id);
SelectedWeb.Context.ExecuteQueryRetry();
var workflowSubscriptionId = default(Nullable <Guid>);
if (!string.IsNullOrEmpty(WorkflowName))
{
var servicesManager = new WorkflowServicesManager(ClientContext, SelectedWeb);
var subscriptionService = servicesManager.GetWorkflowSubscriptionService();
var subscriptions = subscriptionService.EnumerateSubscriptionsByList(list.Id);
//foreach (WorkflowSubscription subs1 in subscriptions)
//{
// if (subs1.Name == WorkflowName) { ClientContext.Load(subs1); }
//}
ClientContext.Load(subscriptions);
ClientContext.ExecuteQueryRetry();
if (subscriptions.Any(subs => subs.Name == WorkflowName))
{
var subscription = subscriptions.FirstOrDefault(subs => subs.Name == WorkflowName);
workflowSubscriptionId = subscription.Id;
}
}
// Check if the field exists
var viewFields = new string[] { "Id", "Title", WorkflowColumnName };
var viewFieldXml = CAML.ViewFields(viewFields.Select(s => CAML.FieldRef(s)).ToArray());
var internalFields = new List <string>();
internalFields.AddRange(viewFields);
try
{
var checkFields = list.GetFields(internalFields.ToArray());
}
catch (Exception ex)
{
LogError(ex, $"Failed to retreive the fields {string.Join(";", viewFields)} with Msg {ex.Message}");
return;
}
var itemIds = new List <int>();
var viewCaml = new CamlQuery()
{
ViewXml = CAML.ViewQuery(
ViewScope.RecursiveAll,
CAML.Where(CAML.Neq(CAML.FieldValue(WorkflowColumnName, FieldType.WorkflowStatus.ToString("f"), WorkflowStatus.Completed.ToString("D")))),
string.Empty,
viewFieldXml,
100)
};
ListItemCollectionPosition itemPosition = null;
while (true)
{
viewCaml.ListItemCollectionPosition = itemPosition;
var items = list.GetItems(viewCaml);
list.Context.Load(items);
list.Context.ExecuteQueryRetry();
itemPosition = items.ListItemCollectionPosition;
foreach (var item in items)
{
itemIds.Add(item.Id);
}
if (itemPosition == null)
{
break;
}
}
// Workflow status to re-start!
var workflowStati = new List <Microsoft.SharePoint.Client.WorkflowServices.WorkflowStatus>()
{
Microsoft.SharePoint.Client.WorkflowServices.WorkflowStatus.Started,
Microsoft.SharePoint.Client.WorkflowServices.WorkflowStatus.Suspended,
Microsoft.SharePoint.Client.WorkflowServices.WorkflowStatus.Invalid
};
foreach (var itemId in itemIds)
{
// Retreive the ListItem
var item = list.GetItemById("" + itemId);
list.Context.Load(item, ictx => ictx.Id, ictx => ictx.ParentList.Id);
list.Context.ExecuteQueryRetry();
// Variables for processing
var subscriptionIds = new List <Guid>();
var allinstances = SelectedWeb.GetWorkflowInstances(item);
var terminationInstances = allinstances.Where(instance => workflowStati.Any(ws => ws == instance.Status) &&
(!workflowSubscriptionId.HasValue || (!workflowSubscriptionId.HasValue && instance.WorkflowSubscriptionId == workflowSubscriptionId))).ToList();
// Cancel the existing failed workflow instances
foreach (var instance in terminationInstances)
{
var instanceId = instance.Id;
subscriptionIds.Add(instance.WorkflowSubscriptionId);
var msg = string.Format("List Item {0} => Cancelling subscription {1} instance Id {2}", itemId, instance.WorkflowSubscriptionId, instanceId);
if (ShouldProcess(msg))
{
instance.CancelWorkFlow();
LogWarning("List Item {0} => Cancelled subscription {1} instance Id {2}", itemId, instance.WorkflowSubscriptionId, instanceId);
}
}
// Instantiate the workflow subscription
foreach (var subscriptionId in subscriptionIds)
{
var msg = string.Format("List Item {0} => Start workflow subscription id {1}", itemId, subscriptionId);
if (ShouldProcess(msg))
{
var instanceId = item.StartWorkflowInstance(subscriptionId, new Dictionary <string, object>());
LogWarning("List Item {0} => Successfully restarted subscription {1} with new instance Id {2}", itemId, subscriptionId, instanceId);
}
}
// Retreive the Item workflow instances and print to the console
var instances = SelectedWeb.GetWorkflowInstances(item);
foreach (var instance in instances)
{
LogVerbose("List Item {0} => Instance {1} => Status {2} => WF Status {3} => Created {4} => LastUpdated {5} => Subscription {6}", itemId, instance.Id, instance.Status, instance.UserStatus, instance.InstanceCreated, instance.LastUpdated, instance.WorkflowSubscriptionId);
}
}
}
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");
}
}
/// <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);
}
public override void ExecuteCmdlet()
{
base.ExecuteCmdlet();
var objects = new List <SPWorkflowInstance>();
var FieldDefinitions = new List <SPFieldDefinitionModel>
{
new SPFieldDefinitionModel(FieldType.Boolean)
{
FieldGuid = new Guid("da2872c4-e9b6-4804-9837-6e9dd85ecd7e"),
InternalName = FieldBoolean_RestartWorkflow,
Description = "RestartWorkflow provides a way to identify items that should be restarted.",
Title = FieldBoolean_RestartWorkflow,
MaxLength = 255,
DefaultValue = "No"
}
};
var SelectedWeb = this.ClientContext.Web;
Ilogger = new DefaultUsageLogger(
(string msg, object[] margs) =>
{
LogVerbose(msg, margs);
},
(string msg, object[] margs) =>
{
LogWarning(msg, margs);
},
(Exception ex, string msg, object[] margs) =>
{
LogError(ex, msg, margs);
});
var list = List.GetList(SelectedWeb, lctx => lctx.Id, lctx => lctx.Title);
var workflowSubscriptionId = new List <Guid>();
if (!string.IsNullOrEmpty(WorkflowName))
{
var servicesManager = new WorkflowServicesManager(ClientContext, SelectedWeb);
var subscriptionService = servicesManager.GetWorkflowSubscriptionService();
var subscriptions = subscriptionService.EnumerateSubscriptionsByList(list.Id);
ClientContext.Load(subscriptions);
ClientContext.ExecuteQueryRetry();
subscriptions.Where(subs => subs.Name == WorkflowName).Select(s => s.Id).ToList().ForEach(subscriptionId =>
{
workflowSubscriptionId.Add(subscriptionId);
});
}
// Check if the field exists
var viewFields = new string[] { "Id", "Title", FieldBoolean_RestartWorkflow };
var internalFields = new List <string>();
internalFields.AddRange(FieldDefinitions.Select(s => s.InternalName));
try
{
var checkFields = list.GetFields(internalFields.ToArray());
}
catch (Exception ex)
{
Ilogger.LogError(ex, "Failed to retreive the fields {0}", ex.Message);
foreach (var field in FieldDefinitions)
{
// provision the column
var provisionedColumn = list.CreateListColumn(field, Ilogger, null);
if (provisionedColumn != null)
{
internalFields.Add(provisionedColumn.InternalName);
}
}
}
var view = View.GetView(list);
var internalViewFieldXml = new List <string>()
{
CAML.FieldRef("Id")
};
foreach (var vfield in view.ViewFields.Where(w => !w.Equals("ID", StringComparison.CurrentCultureIgnoreCase)))
{
internalViewFieldXml.Add(CAML.FieldRef(vfield));
}
var itemIds = new List <int>();
var viewCaml = new CamlQuery()
{
ViewXml = CAML.ViewQuery(ViewScope.RecursiveAll, view.ViewQuery, string.Empty, CAML.ViewFields(internalViewFieldXml.ToArray()), view.RowLimit.ToString().ToInt32(5)),
ListItemCollectionPosition = null
};
do
{
var items = list.GetItems(viewCaml);
this.ClientContext.Load(items, ftx => ftx.ListItemCollectionPosition, ftx => ftx.Include(ftcx => ftcx.Id, ftcx => ftcx.ParentList.Id, ftcx => ftcx[FieldBoolean_RestartWorkflow]));
this.ClientContext.ExecuteQueryRetry();
viewCaml.ListItemCollectionPosition = items.ListItemCollectionPosition;
foreach (var item in items)
{
// Load ParentList ID to Pull Workflow Instances
var allinstances = SelectedWeb.GetWorkflowInstances(item);
if (allinstances.Any())
{
foreach (var instance in allinstances)
{
objects.Add(new SPWorkflowInstance(instance, item.Id));
}
itemIds.Add(item.Id);
}
}
}while (viewCaml.ListItemCollectionPosition != null);
var rowprocessed = itemIds.Count();
if (rowprocessed > 0 && this.ShouldProcess($"Setting Restart Flag for {rowprocessed} items"))
{
var rowdx = 0; var totaldx = rowprocessed;
foreach (var itemId in itemIds)
{
rowdx++;
totaldx--;
var wfItem = list.GetItemById(itemId);
list.Context.Load(wfItem);
wfItem[FieldBoolean_RestartWorkflow] = true;
wfItem.SystemUpdate();
if (rowdx >= 50 || totaldx <= 0)
{
list.Context.ExecuteQueryRetry();
Ilogger.LogInformation($"Processing {rowprocessed} rows; Persisted {rowdx} rows; {totaldx} remaining");
rowdx = 0;
}
}
var cancelDirty = false;
var viewFieldXml = CAML.ViewFields(viewFields.Select(s => CAML.FieldRef(s)).ToArray());
var terminatedWFCaml = new CamlQuery()
{
ViewXml = CAML.ViewQuery(ViewScope.RecursiveAll, CAML.Where(CAML.Eq(CAML.FieldValue(FieldBoolean_RestartWorkflow, FieldType.Boolean.ToString("f"), 1.ToString()))), string.Empty, viewFieldXml, 100),
ListItemCollectionPosition = null
};
do
{
var items = list.GetItems(terminatedWFCaml);
list.Context.Load(items, ftx => ftx.ListItemCollectionPosition, ftx => ftx.Include(ftcx => ftcx.Id, ftcx => ftcx.ParentList.Id, ftcx => ftcx[FieldBoolean_RestartWorkflow]));
list.Context.ExecuteQueryRetry();
terminatedWFCaml.ListItemCollectionPosition = items.ListItemCollectionPosition;
rowdx = 0; totaldx = items.Count();
foreach (var item in items)
{
rowdx++;
totaldx--;
var itemId = item.Id;
var allinstances = SelectedWeb.GetWorkflowInstances(item);
foreach (var instance in allinstances)
{
var instanceId = instance.Id;
var msg = $"List Item {itemId} => Cancelling subscription {instance.WorkflowSubscriptionId} instance Id {instanceId}";
Ilogger.LogWarning(msg);
cancelDirty = true;
instance.CancelWorkFlow();
}
if (cancelDirty &&
(rowdx >= 50 || totaldx <= 0))
{
list.Context.ExecuteQueryRetry();
Ilogger.LogInformation($"Processing {rowprocessed} rows; Persisted {rowdx} rows; {totaldx} remaining");
rowdx = 0;
}
}
}while (terminatedWFCaml.ListItemCollectionPosition != null);
}
WriteObject(objects, true);
}
/// <summary>
/// Processing
/// </summary>
public override void ExecuteCmdlet()
{
base.ExecuteCmdlet();
var paramlistname = List.Title;
var paramviewname = View.Title;
this.ColumnMappings = new List <FieldMappings>();
var documentsetcontenttypeid = "0x0120D520";
try
{
var viewlist = ClientContext.Web.GetListByTitle(paramlistname);
ClientContext.Load(viewlist, rcll => rcll.Fields, rcll => rcll.ItemCount, rcll => rcll.ContentTypes, rcll => rcll.BaseType, rcll => rcll.RootFolder);
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 (!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());
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
});
});
var camlQueryXml = CAML.ViewQuery(ViewScope.RecursiveAll, queryWhereCaml, queryOrderCaml, queryViewCaml, 500);
ListItemCollectionPosition camlListItemCollectionPosition = null;
var camlQuery = new CamlQuery();
camlQuery.ViewXml = camlQueryXml;
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 spItem in spListItems)
{
var fileurl = spItem.RetrieveListItemValue(ConstantsFields.Field_FileRef);
var progid = spItem.RetrieveListItemValue("ProgId");
LogVerbose("Item {0} ProgId {1} URL:{2}", spItem.Id, progid, fileurl);
var contenttypeid = spItem.RetrieveListItemValue("ContentTypeId");
if (contenttypeid.StartsWith(documentsetcontenttypeid) || progid.Equals("Sharepoint.DocumentSet", StringComparison.CurrentCultureIgnoreCase))
{
// process the docset
CheckDocumentSetMapping(viewlist, fileurl);
// process items inside the docset
CheckDocumentsByCaml(viewlist, viewFields, fileurl);
}
}
if (camlListItemCollectionPosition == null)
{
break;
}
}
}
}
catch (Exception fex)
{
LogError(fex, "Failed to parse view and produce HTML report");
}
}
/// <summary>
/// Builds a Field Creation Info object from the Definition model and returns its resulting XML
/// </summary>
/// <param name="host">The instantiated web/list/library to which the field will be added</param>
/// <param name="fieldDefinition">The definition pulled from a SP Site or user construction</param>
/// <param name="siteGroups">The collection of site groups that a user/group field make filter</param>
/// <param name="provisionerChoices">(OPTIONAL) The collection of hoice lookups as defined in the serialized JSON file</param>
/// <returns></returns>
public static string CreateFieldDefinition(this SecurableObject host, SPFieldDefinitionModel fieldDefinition, List <SPGroupDefinitionModel> siteGroups, List <SiteProvisionerFieldChoiceModel> provisionerChoices = null)
{
var idguid = fieldDefinition.FieldGuid;
var choiceXml = string.Empty;
var defaultChoiceXml = string.Empty;
var formulaXml = string.Empty;
var fieldReferenceXml = string.Empty;
var attributes = new List <KeyValuePair <string, string> >();
if (string.IsNullOrEmpty(fieldDefinition.InternalName))
{
throw new ArgumentNullException("InternalName");
}
if (string.IsNullOrEmpty(fieldDefinition.Title))
{
throw new ArgumentNullException("DisplayName");
}
if (!string.IsNullOrEmpty(fieldDefinition.PeopleGroupName) && (siteGroups == null || siteGroups.Count() <= 0))
{
throw new ArgumentNullException("SiteGroups", string.Format("You must specify a collection of group for the field {0}", fieldDefinition.Title));
}
if (string.IsNullOrEmpty(fieldDefinition.LookupListName) && fieldDefinition.FieldTypeKind == FieldType.Lookup)
{
throw new ArgumentNullException("LookupListName", string.Format("you must specify a lookup list title for the field {0}", fieldDefinition.Title));
}
if (fieldDefinition.LoadFromJSON && (provisionerChoices == null || !provisionerChoices.Any(pc => pc.FieldInternalName == fieldDefinition.InternalName)))
{
throw new ArgumentNullException("provisionerChoices", string.Format("You must specify a collection of field choices for the field {0}", fieldDefinition.Title));
}
if (!string.IsNullOrEmpty(fieldDefinition.Description))
{
attributes.Add(new KeyValuePair <string, string>("Description", fieldDefinition.Description.UnescapeXml().EscapeXml(true)));
}
if (fieldDefinition.FieldIndexed)
{
attributes.Add(new KeyValuePair <string, string>("Indexed", fieldDefinition.FieldIndexed.ToString().ToUpper()));
}
if (fieldDefinition.AppendOnly)
{
attributes.Add(new KeyValuePair <string, string>("AppendOnly", fieldDefinition.AppendOnly.ToString().ToUpper()));
}
var choices = new FieldType[] { FieldType.Choice, FieldType.GridChoice, FieldType.MultiChoice, FieldType.OutcomeChoice };
if (choices.Any(a => a == fieldDefinition.FieldTypeKind))
{
if (fieldDefinition.LoadFromJSON &&
(provisionerChoices != null && provisionerChoices.Any(fc => fc.FieldInternalName == fieldDefinition.InternalName)))
{
var choicecontents = provisionerChoices.FirstOrDefault(fc => fc.FieldInternalName == fieldDefinition.InternalName);
fieldDefinition.FieldChoices.Clear();
fieldDefinition.FieldChoices.AddRange(choicecontents.Choices);
}
//AllowMultipleValues
if (fieldDefinition.MultiChoice)
{
attributes.Add(new KeyValuePair <string, string>("Mult", fieldDefinition.MultiChoice.ToString().ToUpper()));
}
choiceXml = string.Format("<CHOICES>{0}</CHOICES>", string.Join("", fieldDefinition.FieldChoices.Select(s => string.Format("<CHOICE>{0}</CHOICE>", s.Choice.Trim())).ToArray()));
if (!string.IsNullOrEmpty(fieldDefinition.ChoiceDefault))
{
defaultChoiceXml = string.Format("<Default>{0}</Default>", fieldDefinition.ChoiceDefault);
}
if (fieldDefinition.FieldTypeKind == FieldType.Choice)
{
attributes.Add(new KeyValuePair <string, string>("Format", fieldDefinition.ChoiceFormat.ToString("f")));
}
}
else if (fieldDefinition.FieldTypeKind == FieldType.DateTime)
{
if (fieldDefinition.DateFieldFormat.HasValue)
{
attributes.Add(new KeyValuePair <string, string>("Format", fieldDefinition.DateFieldFormat.Value.ToString("f")));
}
}
else if (fieldDefinition.FieldTypeKind == FieldType.Note)
{
attributes.Add(new KeyValuePair <string, string>("RichText", fieldDefinition.RichTextField.ToString().ToUpper()));
attributes.Add(new KeyValuePair <string, string>("RestrictedMode", fieldDefinition.RestrictedMode.ToString().ToUpper()));
attributes.Add(new KeyValuePair <string, string>("NumLines", fieldDefinition.NumLines.ToString()));
if (!fieldDefinition.RestrictedMode)
{
attributes.Add(new KeyValuePair <string, string>("RichTextMode", "FullHtml"));
attributes.Add(new KeyValuePair <string, string>("IsolateStyles", true.ToString().ToUpper()));
}
}
else if (fieldDefinition.FieldTypeKind == FieldType.User)
{
//AllowMultipleValues
if (fieldDefinition.MultiChoice)
{
attributes.Add(new KeyValuePair <string, string>("Mult", fieldDefinition.MultiChoice.ToString().ToUpper()));
}
//SelectionMode
if (fieldDefinition.PeopleOnly)
{
attributes.Add(new KeyValuePair <string, string>("UserSelectionMode", FieldUserSelectionMode.PeopleOnly.ToString("d")));
}
if (!string.IsNullOrEmpty(fieldDefinition.PeopleLookupField))
{
attributes.Add(new KeyValuePair <string, string>("ShowField", fieldDefinition.PeopleLookupField));
//fldUser.LookupField = fieldDef.PeopleLookupField;
}
if (!string.IsNullOrEmpty(fieldDefinition.PeopleGroupName))
{
var group = siteGroups.FirstOrDefault(f => f.Title == fieldDefinition.PeopleGroupName);
if (group != null)
{
attributes.Add(new KeyValuePair <string, string>("UserSelectionScope", group.Id.ToString()));
}
}
}
else if (fieldDefinition.FieldTypeKind == FieldType.Lookup)
{
var lParentList = host.GetAssociatedWeb().GetListByTitle(fieldDefinition.LookupListName);
var strParentListID = lParentList.Id;
attributes.Add(new KeyValuePair <string, string>("EnforceUniqueValues", false.ToString().ToUpper()));
attributes.Add(new KeyValuePair <string, string>("List", strParentListID.ToString("B")));
attributes.Add(new KeyValuePair <string, string>("ShowField", fieldDefinition.LookupListFieldName));
if (fieldDefinition.MultiChoice)
{
attributes.Add(new KeyValuePair <string, string>("Mult", fieldDefinition.MultiChoice.ToString().ToUpper()));
}
}
else if (fieldDefinition.FieldTypeKind == FieldType.Calculated)
{
attributes.Add(new KeyValuePair <string, string>("ResultType", fieldDefinition.OutputType.Value.ToString("f")));
formulaXml = string.Format("<Formula>{0}</Formula>", fieldDefinition.DefaultFormula.UnescapeXml().EscapeXml());
fieldReferenceXml = string.Format("<FieldRefs>{0}</FieldRefs>", string.Join("", fieldDefinition.FieldReferences.Select(s => CAML.FieldRef(s.Trim())).ToArray()));
}
// construct the XML
var finfo = fieldDefinition.ToCreationObject();
finfo.AdditionalAttributes = attributes;
var finfoXml = FieldAndContentTypeExtensions.FormatFieldXml(finfo);
if (!string.IsNullOrEmpty(choiceXml))
{
XDocument xd = XDocument.Parse(finfoXml);
XElement root = xd.FirstNode as XElement;
if (!string.IsNullOrEmpty(defaultChoiceXml))
{
root.Add(XElement.Parse(defaultChoiceXml));
}
root.Add(XElement.Parse(choiceXml));
finfoXml = xd.ToString();
}
if (!string.IsNullOrEmpty(formulaXml))
{
XDocument xd = XDocument.Parse(finfoXml);
XElement root = xd.FirstNode as XElement;
root.Add(XElement.Parse(formulaXml));
if (!string.IsNullOrEmpty(fieldReferenceXml))
{
root.Add(XElement.Parse(fieldReferenceXml));
}
finfoXml = xd.ToString();
}
return(finfoXml);
}
public override void ExecuteCmdlet()
{
base.ExecuteCmdlet();
var objects = new List <SPWorkflowInstance>();
var FieldDefinitions = new List <SPFieldDefinitionModel>
{
new SPFieldDefinitionModel(FieldType.Boolean)
{
FieldGuid = new Guid("da2872c4-e9b6-4804-9837-6e9dd85ecd7e"),
InternalName = FieldBoolean_RestartWorkflow,
Description = "RestartWorkflow provides a way to identify items that should be restarted.",
Title = FieldBoolean_RestartWorkflow,
MaxLength = 255,
DefaultValue = "No"
}
};
var SelectedWeb = this.ClientContext.Web;
Ilogger = new DefaultUsageLogger(
(string msg, object[] margs) =>
{
LogVerbose(msg, margs);
},
(string msg, object[] margs) =>
{
LogWarning(msg, margs);
},
(Exception ex, string msg, object[] margs) =>
{
LogError(ex, msg, margs);
});
var list = List.GetList(SelectedWeb, lctx => lctx.Id, lctx => lctx.Title);
var workflowSubscriptionId = new List <Guid>();
if (!string.IsNullOrEmpty(WorkflowName))
{
var servicesManager = new WorkflowServicesManager(ClientContext, SelectedWeb);
var subscriptionService = servicesManager.GetWorkflowSubscriptionService();
var subscriptions = subscriptionService.EnumerateSubscriptionsByList(list.Id);
ClientContext.Load(subscriptions);
ClientContext.ExecuteQueryRetry();
subscriptions.Where(subs => subs.Name == WorkflowName).Select(s => s.Id).ToList().ForEach(subscriptionId =>
{
workflowSubscriptionId.Add(subscriptionId);
});
}
// Check if the field exists
var viewFields = new string[] { "Id", "Title", FieldBoolean_RestartWorkflow };
var internalFields = new List <string>();
internalFields.AddRange(FieldDefinitions.Select(s => s.InternalName));
try
{
var checkFields = list.GetFields(internalFields.ToArray());
}
catch (Exception ex)
{
Ilogger.LogError(ex, "Failed to retreive the fields {0}", ex.Message);
foreach (var field in FieldDefinitions)
{
// provision the column
var provisionedColumn = list.CreateListColumn(field, Ilogger, null);
if (provisionedColumn != null)
{
internalFields.Add(provisionedColumn.InternalName);
}
}
}
var workflowStati = new List <Microsoft.SharePoint.Client.WorkflowServices.WorkflowStatus>()
{
Microsoft.SharePoint.Client.WorkflowServices.WorkflowStatus.Started
};
var rowprocessed = 0;
var rowdx = 0; var totaldx = 0;
var startedDirty = false;
var viewFieldXml = CAML.ViewFields(viewFields.Select(s => CAML.FieldRef(s)).ToArray());
var initiateWFCaml = new CamlQuery()
{
ViewXml = CAML.ViewQuery(ViewScope.RecursiveAll, CAML.Where(CAML.Eq(CAML.FieldValue(FieldBoolean_RestartWorkflow, FieldType.Boolean.ToString("f"), 1.ToString()))), string.Empty, viewFieldXml, 100),
ListItemCollectionPosition = null
};
do
{
var items = list.GetItems(initiateWFCaml);
list.Context.Load(items, ftx => ftx.ListItemCollectionPosition, ftx => ftx.Include(ftcx => ftcx.Id, ftcx => ftcx.ParentList.Id, ftcx => ftcx[FieldBoolean_RestartWorkflow]));
list.Context.ExecuteQueryRetry();
initiateWFCaml.ListItemCollectionPosition = items.ListItemCollectionPosition;
rowprocessed = items.Count();
rowdx = 0; totaldx = rowprocessed;
foreach (var item in items)
{
rowdx++;
totaldx--;
var itemId = item.Id;
var allinstances = SelectedWeb.GetWorkflowInstances(item);
if (!allinstances.Any(w => workflowStati.Any(wx => wx == w.Status)))
{
foreach (var subscriptionId in workflowSubscriptionId)
{
Ilogger.LogWarning($"List Item {itemId} => Restarting subscription {subscriptionId}");
var instanceId = item.StartWorkflowInstance(subscriptionId, new Dictionary <string, object>());
Ilogger.LogWarning($"List Item {itemId} => Successfully restarted subscription {subscriptionId} with new instance Id {instanceId}");
startedDirty = true;
objects.Add(new SPWorkflowInstance()
{
Id = instanceId,
WorkflowSubscriptionId = subscriptionId,
ListItemId = itemId,
InstanceCreated = DateTime.UtcNow
});
}
var wfItem = list.GetItemById(itemId);
list.Context.Load(wfItem);
wfItem[FieldBoolean_RestartWorkflow] = false;
wfItem.SystemUpdate();
}
if (startedDirty && (rowdx >= 50 || totaldx <= 0))
{
list.Context.ExecuteQueryRetry();
Ilogger.LogInformation($"Processing {rowprocessed} rows; Persisted {rowdx} rows; {totaldx} remaining");
rowdx = 0;
}
}
}while (initiateWFCaml.ListItemCollectionPosition != null);
WriteObject(objects, true);
}
public override void ExecuteCmdlet()
{
base.ExecuteCmdlet();
var invalidLinks = new List <dynamic>();
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);
var item = onlineLibrary.GetItemById(ItemId);
this.ClientContext.Load(item);
this.ClientContext.ExecuteQueryRetry();
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);
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);
}
/// <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);
}
/// <summary>
/// Retrieves or creates the folder as a ListItem
/// </summary>
/// <param name="onlineLibrary">The target list for the folder</param>
/// <param name="destinationFolder">The parent folder of the folter to be created</param>
/// <param name="folderName">The folder to be created</param>
/// <param name="defaultStartItemId">(OPTIONAL) If the list/library is above the threshold this will be the start index of the caml queries</param>
/// <param name="defaultLastItemId">(OPTIONAL) If the list/library is above the threshold this will be the terminating index of the caml queries</param>
/// <returns>The listitem as a folder</returns>
public static Folder GetOrCreateFolder(this List onlineLibrary, Folder destinationFolder, string folderName, Nullable <int> defaultStartItemId = default(int?), Nullable <int> defaultLastItemId = default(int?))
{
if (!onlineLibrary.IsPropertyAvailable(lctx => lctx.BaseType))
{
onlineLibrary.Context.Load(onlineLibrary, lctx => lctx.BaseType, lctx => lctx.BaseTemplate);
onlineLibrary.Context.ExecuteQueryRetry();
}
if (!destinationFolder.IsPropertyAvailable(fctx => fctx.ServerRelativeUrl) ||
!destinationFolder.IsObjectPropertyInstantiated(fctx => fctx.Folders))
{
destinationFolder.Context.Load(destinationFolder, afold => afold.ServerRelativeUrl, afold => afold.Folders);
destinationFolder.Context.ExecuteQueryRetry();
}
ListItem folderItem = null;
var folderRelativeUrl = destinationFolder.ServerRelativeUrl;
var camlFields = new string[] { "Title", "ID" };
var camlViewFields = CAML.ViewFields(camlFields.Select(s => CAML.FieldRef(s)).ToArray());
// Remove invalid characters
var trimmedFolder = HelperExtensions.GetCleanDirectory(folderName, string.Empty);
var linkFileFilter = CAML.Eq(CAML.FieldValue("Title", FieldType.Text.ToString("f"), trimmedFolder));
if (onlineLibrary.BaseType == BaseType.DocumentLibrary)
{
linkFileFilter = CAML.Or(
linkFileFilter,
CAML.Eq(CAML.FieldValue("LinkFilename", FieldType.Text.ToString("f"), trimmedFolder)));
}
var camlClause = CAML.And(
CAML.Eq(CAML.FieldValue("FileDirRef", FieldType.Text.ToString("f"), folderRelativeUrl)),
CAML.And(
CAML.Eq(CAML.FieldValue("FSObjType", FieldType.Integer.ToString("f"), 1.ToString())),
linkFileFilter
)
);
var camlQueries = onlineLibrary.SafeCamlClauseFromThreshold(1000, camlClause, defaultStartItemId, defaultLastItemId);
foreach (var camlAndValue in camlQueries)
{
ListItemCollectionPosition itemPosition = null;
var camlWhereClause = CAML.Where(camlAndValue);
var camlQuery = new CamlQuery()
{
ViewXml = CAML.ViewQuery(
ViewScope.RecursiveAll,
camlWhereClause,
string.Empty,
camlViewFields,
5)
};
camlQuery.ListItemCollectionPosition = itemPosition;
var listItems = onlineLibrary.GetItems(camlQuery);
onlineLibrary.Context.Load(listItems, lti => lti.ListItemCollectionPosition);
onlineLibrary.Context.ExecuteQueryRetry();
if (listItems.Count() > 0)
{
folderItem = listItems.FirstOrDefault();
System.Diagnostics.Trace.TraceInformation("Folder {0} exists in the destination folder. Skip folder creation .....", folderName);
break;
}
}
;
if (folderItem != null)
{
return(folderItem.Folder);
}
try
{
var info = new ListItemCreationInformation
{
UnderlyingObjectType = FileSystemObjectType.Folder,
LeafName = trimmedFolder,
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);
}
/// <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();
LogVerbose("Scanning CSOM callout");
var invalidLinks = new List <CalloutLinkModel>();
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);
if (!EndId.HasValue)
{
onlineLibrary.EnsureProperties(ol => ol.ItemCount);
EndId = onlineLibrary.ItemCount;
}
ListItemCollectionPosition itemCollectionPosition = null;
CamlQuery camlQuery = new CamlQuery();
for (var idx = 1; idx <= EndId; idx += 1000)
{
camlQuery.ViewXml = string.Format(@"<View Scope='RecursiveAll'><Query>
<OrderBy><FieldRef Name='ID' /></OrderBy>
<Where>
<And>
<And>
{0}{1}
</And>
<Or>
{2}{3}
</Or>
</And>
</Where>
{4}
<RowLimit Paged='TRUE'>30</RowLimit>
</Query></View>",
CAML.Geq(CAML.FieldValue("ID", FieldType.Integer.ToString("f"), idx.ToString())),
CAML.Leq(CAML.FieldValue("ID", FieldType.Integer.ToString("f"), (idx + 1000).ToString())),
CAML.Eq(CAML.FieldValue("FileDirRef", FieldType.Text.ToString("f"), Path)),
CAML.Contains(CAML.FieldValue("_dlc_DocIdUrl", FieldType.URL.ToString("f"), PartialUrl)),
fieldsXml
);
while (true)
{
camlQuery.ListItemCollectionPosition = itemCollectionPosition;
ListItemCollection listItems = onlineLibrary.GetItems(camlQuery);
this.ClientContext.Load(listItems);
this.ClientContext.ExecuteQuery();
itemCollectionPosition = listItems.ListItemCollectionPosition;
if (listItems.Count() > 0)
{
foreach (var listItem in listItems)
{
var item = onlineLibrary.GetItemById(listItem.Id);
this.ClientContext.Load(item);
this.ClientContext.ExecuteQuery();
var docId = item.RetrieveListItemValue("_dlc_DocId");
var docIdUrl = item.RetrieveListItemValueAsHyperlink("_dlc_DocIdUrl");
var modified = item.RetrieveListItemValue("Modified").ToDateTime();
var editor = item.RetrieveListItemUserValue("Editor");
var redirectEmbeddedUrl = item.RetrieveListItemValue("ServerRedirectedEmbedUri");
var fileRef = item.RetrieveListItemValue("FileRef");
var title = item.RetrieveListItemValue("Title");
invalidLinks.Add(new CalloutLinkModel()
{
DocId = docId,
DocIdUrl = (docIdUrl == null) ? string.Empty : docIdUrl.Url,
Modified = modified,
EditorEmail = (editor == null) ? string.Empty : editor.ToUserEmailValue(),
EmbeddedUrl = redirectEmbeddedUrl,
FileUrl = fileRef,
Title = title,
Id = listItem.Id
});
}
}
if (itemCollectionPosition == null)
{
break;
}
}
}
WriteObject(invalidLinks);
}
