public DocumentSetPipeBind()
{
_id = string.Empty;
_name = string.Empty;
_contentType = null;
_documentSetTemplate = null;
}
public ActionResult DeleteWelcomeField(string id)
{
var spContext = SharePointContextProvider.Current.GetSharePointContext(HttpContext);
using (var clientContext = spContext.CreateUserClientContextForSPHost())
{
clientContext.Load(clientContext.Web, w => w.ContentTypes);
clientContext.ExecuteQuery();
ContentType docSetContentType = clientContext.Web.ContentTypes.FirstOrDefault(ct => ct.Name == CONTENTTYPENAME);
Field selectedField = clientContext.Web.Fields.GetById(new Guid(id));
clientContext.Load(selectedField);
clientContext.ExecuteQuery();
if (docSetContentType != null && selectedField.ServerObjectIsNull == false)
{
DocumentSetTemplate docSetTemplate = DocumentSetTemplate.GetDocumentSetTemplate(clientContext, docSetContentType);
clientContext.Load(docSetTemplate, d => d.WelcomePageFields);
clientContext.ExecuteQuery();
if (!docSetTemplate.WelcomePageFields.Contains(selectedField))
{
docSetTemplate.WelcomePageFields.Remove(new Guid(id));
docSetTemplate.Update(true);
clientContext.ExecuteQuery();
}
}
}
return(RedirectToAction("Index", new { SPHostUrl = SharePointContext.GetSPHostUrl(HttpContext.Request).AbsoluteUri }));
}
public static void Add(this DocumentSetTemplate documentSet, ListItem documentItem, string documentSetName, string folder, ContentTypeId docId, bool majorVersionOnly)
{
Trace.TraceInformation($"Adding: {documentItem.File.Name} to {documentSetName}, Document Folder: {folder}");
var ctx = documentSet.Context;
Uri webUrl = new Uri(ctx.Url);
DocumentStream ds = new DocumentStream((ClientContext)ctx, documentItem);
MemoryStream documentStream;
if (majorVersionOnly)
{
documentStream = ds.MajorVersion;
}
else
{
documentStream = ds.LatestVersion;
}
//Use a place holder to workaround filesize limitation with the DefaultDocuments API.
//Place holder is inserted via the API, and then overwritten later.
if (documentStream != null)
{
string placeholderPage = "Placeholder";
MemoryStream repo = new MemoryStream(Encoding.UTF8.GetBytes(placeholderPage));
documentSet.DefaultDocuments.Add(folder + ds.FileName, docId, repo.ToArray());
documentSet.Update(true);
ctx.ExecuteQuery();
repo.Close();
Trace.TraceInformation("- Placeholder created");
UploadFile((ClientContext)ctx, webUrl.AbsolutePath + "/_cts/" + documentSetName, documentStream, documentItem.File.Name);
}
}
public DocumentSetTemplate GetDocumentSetTemplate(Web web)
{
if (_contentType != null)
{
var docSet = DocumentSetTemplate.GetDocumentSetTemplate(web.Context, _contentType);
return(docSet);
}
else if (_documentSetTemplate != null)
{
return(_documentSetTemplate);
}
else
{
ContentType ct;
if (!string.IsNullOrEmpty(Id))
{
ct = web.GetContentTypeById(Id, true);
}
else
{
ct = web.GetContentTypeByName(Name, true);
}
var docSet = DocumentSetTemplate.GetDocumentSetTemplate(web.Context, ct);
return(docSet);
}
}
public ActionResult DeleteAllowedContentTypeAction(string id)
{
var spContext = SharePointContextProvider.Current.GetSharePointContext(HttpContext);
using (var clientContext = spContext.CreateUserClientContextForSPHost())
{
if (clientContext != null)
{
Web web = clientContext.Web;
clientContext.Load(web, w => w.ContentTypes, w => w.Fields);
clientContext.ExecuteQuery();
var query = from ct in web.ContentTypes
where ct.Id.StringValue == id
select ct;
ContentType ctFound = query.First();
DocumentSetTemplate template = GetDocumentSetTemplate(clientContext);
if (template != null)
{
template.AllowedContentTypes.Remove(ctFound.Id);
template.Update(true);
clientContext.Load(template);
clientContext.ExecuteQuery();
}
}
}
return(RedirectToAction("Index", new { SPHostUrl = SharePointContext.GetSPHostUrl(HttpContext.Request).AbsoluteUri }));
}
public DocumentSetPipeBind()
{
_id = string.Empty;
_name = string.Empty;
_contentType = null;
_documentSetTemplate = null;
}
public static void Clear(this DocumentSetTemplate documentSet)
{
var ctx = documentSet.Context;
string[] docs = new string[200];
int j = 0;
foreach (var document in documentSet.DefaultDocuments)
{
docs[j] = document.Name;
j++;
}
Trace.TraceInformation($"Documents for deletion from Documentset");
foreach (var document in docs)
{
if (string.IsNullOrEmpty(document))
{
break;
}
documentSet.DefaultDocuments.Remove(document);
documentSet.Update(true);
ctx.ExecuteQuery();
}
}
public void Run()
{
Trace.TraceInformation("Document Set Manager Initiated");
List documentLibrary = DocumentWeb.Lists.GetByTitle(Config.DocumentLibrary);
Folder rootFolder = documentLibrary.RootFolder;
Ctx.Load(documentLibrary);
Ctx.Load(rootFolder, i => i.Folders, i => i.Name);
Ctx.ExecuteQuery();
foreach (KeyValuePair <string, string> folderToDocumentMap in Config.FolderToDocumentSetMapping)
{
Trace.TraceInformation($"Mapping: {folderToDocumentMap.Key} to {folderToDocumentMap.Value}. Major Versions Only: {Config.MajorVersionsOnly}");
ContentType documentSetCt = DocumentWeb.ContentTypes.GetByName(folderToDocumentMap.Value);
Folder folder = rootFolder.Folders.GetByName(folderToDocumentMap.Key);
DocumentSetTemplate dst = DocumentSetTemplate.GetDocumentSetTemplate(Ctx, documentSetCt);
Ctx.Load(documentSetCt);
Ctx.Load(folder);
Ctx.Load(dst, i => i.DefaultDocuments);
Ctx.ExecuteQuery();
Trace.TraceInformation($"Deleting existing documents from the {folderToDocumentMap.Value}");
dst.Clear();
CamlQuery cq = CreateAllFilesQuery();
cq.FolderServerRelativeUrl = folder.ServerRelativeUrl;
ListItemCollection documents = documentLibrary.GetItems(cq);
Ctx.Load(documents, icol => icol.Include(i => i.File));
Ctx.Load(documents, icol => icol.Include(i => i.ContentType));
Ctx.Load(documents, icol => icol.Include(i => i.ContentType.Id));
Ctx.ExecuteQuery();
Trace.TraceInformation($"Returned {documents.Count} files for processing");
int count = 0;
foreach (ListItem document in documents)
{
count++;
ContentType docCt = DocumentWeb.ContentTypes.GetByName(document.ContentType.Name);
Ctx.ExecuteQuery();
string contentTypeFolder = ContentTypeFolder(document, rootFolder, folder);
if (Config.ExcludedFolders.Contains(contentTypeFolder.TrimEnd('/'), StringComparer.CurrentCultureIgnoreCase))
{
Trace.TraceInformation($"{document.File.Name} not proceesed due to ExcludedFolder rule: {contentTypeFolder.TrimEnd('/')}");
continue;
}
Trace.TraceInformation($"Adding document {count}: {document.File.Name}");
dst.Add(document, folderToDocumentMap.Value, contentTypeFolder, docCt.Id, Config.MajorVersionsOnly);
dst.Update(true);
Ctx.ExecuteQuery();
}
}
}
/// <summary>
/// Add fields, content types end event receivers to list
/// </summary>
/// <param name="web"></param>
private void AddFieldsCtToLists(SPWeb web)
{
SPContentType invoice = web.Site.RootWeb.ContentTypes[new SPContentTypeId("0x0101006667822C2C904046B11878F79EFAF7A6")];
invoice.JSLink = "~sitecollection/SiteAssets/Scripts/jquery-3.1.0.min.js | ~sitecollection/SiteAssets/Scripts/AddMonth.js";
invoice.Update(true);
SPContentType ltInvoice = web.Site.RootWeb.ContentTypes[new SPContentTypeId("0x0101006667822C2C904046B11878F79EFAF7A60035D6DBDCBCBB47D8B3D9F882A2652E25")];
ltInvoice.JSLink = "~sitecollection/SiteAssets/Scripts/jquery-3.1.0.min.js | ~sitecollection/SiteAssets/Scripts/AddMonth.js";
ltInvoice.Update(true);
SPContentType orderContentType = web.Site.RootWeb.ContentTypes[new SPContentTypeId("0x0120D52000B7FF4D802E3E4631A4AEDDA271D87E78")];
List <string> colnames = new List <string>();
colnames.Add("PredicaNotStandardFee");
colnames.Add("FileLeafRef");
colnames.Add("DocumentSetDescription");
for (int i = 0; i < orderContentType.FieldLinks.Count; i++)
{
if (colnames.Contains(orderContentType.FieldLinks[i].Name))
{
continue;
}
colnames.Add(orderContentType.FieldLinks[i].Name);
}
orderContentType.FieldLinks.Reorder(colnames.ToArray());
orderContentType.FieldLinks[SPBuiltInFieldId.FileLeafRef].DisplayName = "$Resources:PredicaOrders,PredicaColOrderName";
orderContentType.FieldLinks[Guid.Parse("{1fc87c65-f371-46d3-bb42-6174eeaeea6e}")].ReadOnly = true;
DocumentSetTemplate docsetTemplate = DocumentSetTemplate.GetDocumentSetTemplate(orderContentType);
// Setting the content types
docsetTemplate.AllowedContentTypes.Remove(web.ContentTypes["Document"].Id);
docsetTemplate.AllowedContentTypes.Add(invoice.Id);
docsetTemplate.AllowedContentTypes.Add(ltInvoice.Id);
docsetTemplate.Update(true);
orderContentType.Update(true);
string ordersUrl = SPUrlUtility.CombineUrl(web.ServerRelativeUrl.TrimEnd('/'), Orders);
SPList ordersList = web.GetList(ordersUrl);
ordersList.ContentTypesEnabled = true;
ordersList.ContentTypes.Add(orderContentType);
ordersList.ContentTypes.Add(invoice);
ordersList.ContentTypes.Add(ltInvoice);
ordersList.Update();
}
public ActionResult DeleteAll()
{
//return RedirectToAction("Index");
DocumentSetTemplate template = null;
List <ContentTypeModel> model = new List <ContentTypeModel>();
var spContext = SharePointContextProvider.Current.GetSharePointContext(HttpContext);
using (var clientContext = spContext.CreateUserClientContextForSPHost())
{
if (clientContext != null)
{
Web web = clientContext.Web;
clientContext.Load(web, w => w.ContentTypes, w => w.Fields);
clientContext.ExecuteQuery();
foreach (ContentType ct in web.ContentTypes)
{
//find out documentset and child content type
if (ct.Name.IndexOf("document set", StringComparison.CurrentCultureIgnoreCase) != -1 ||
DocumentSetTemplate.IsChildOfDocumentSetContentType(clientContext, ct).Value)
{
template = DocumentSetTemplate.GetDocumentSetTemplate(clientContext, ct);
clientContext.Load(template, t => t.AllowedContentTypes, t => t.DefaultDocuments, t => t.SharedFields, t => t.WelcomePageFields);
clientContext.ExecuteQuery();
foreach (ContentTypeId ctId in template.AllowedContentTypes)
{
ContentType ctAllowed = clientContext.Web.ContentTypes.First(d => d.StringId == ctId.StringValue);
if (ctAllowed != null)
{
model.Add(new ContentTypeModel()
{
Id = ctId, Name = ctAllowed.Name
});
}
}
break;
}
}
}
}
return(View("AllowedContentTypesDeleteAll", model));
}
private DocumentSetTemplate GetDocumentSetTemplate(ClientContext clientContext)
{
DocumentSetTemplate template = null;
Web web = clientContext.Web;
clientContext.Load(web, w => w.ContentTypes, w => w.Fields);
clientContext.ExecuteQuery();
ContentType ctSow = web.ContentTypes.FirstOrDefault(ct => ct.Name == CONTENTTYPENAME);
if (ctSow != null)
{
template = DocumentSetTemplate.GetDocumentSetTemplate(clientContext, ctSow);
clientContext.Load(template, t => t.AllowedContentTypes, t => t.DefaultDocuments, t => t.SharedFields, t => t.WelcomePageFields);
clientContext.ExecuteQuery();
}
return(template);
}
public ActionResult CreateDocumentSet([Bind(Include = "DocumentLibName,FieldNames,ContentTypeName")] AddDocumentSetViewModel model)
{
var spContext = SharePointContextProvider.Current.GetSharePointContext(HttpContext);
using (var clientContext = spContext.CreateUserClientContextForSPHost())
{
List <Field> fields = new List <Field>();
foreach (string fieldName in model.FieldNames)
{
Field field = CreateDocumentSetField(clientContext, fieldName);
fields.Add(field);
}
ContentType ctTestSow = CreateDocumentSetContentType(clientContext, model.ContentTypeName, fields);
DocumentSetTemplate docSetTemplate = DocumentSetTemplate.GetDocumentSetTemplate(clientContext, ctTestSow);
clientContext.Load(docSetTemplate, d => d.SharedFields, d => d.WelcomePageFields);
clientContext.ExecuteQuery();
if (!docSetTemplate.SharedFields.Contains(fields[0]))
{
docSetTemplate.SharedFields.Add(fields[0]);
docSetTemplate.Update(true);
clientContext.ExecuteQuery();
}
if (!docSetTemplate.WelcomePageFields.Contains(fields[0]))
{
docSetTemplate.WelcomePageFields.Add(fields[0]);
docSetTemplate.Update(true);
clientContext.ExecuteQuery();
}
//
List listTestDoc = GetTestDocDocumentLibrary(clientContext, ctTestSow, model.DocumentLibName);
clientContext.Load(listTestDoc.RootFolder);
clientContext.ExecuteQuery();
ClientResult <string> result = DocumentSet.Create(clientContext, listTestDoc.RootFolder, DOCUMENTSETNAME, ctTestSow.Id);
clientContext.ExecuteQuery();
}
return(RedirectToAction("Index", new { SPHostUrl = SharePointContext.GetSPHostUrl(HttpContext.Request).AbsoluteUri }));
}
public ActionResult AllowedContentTypeDeleteAll()
{
DocumentSetTemplate template = null;
List <ContentTypeModel> model = new List <ContentTypeModel>();
var spContext = SharePointContextProvider.Current.GetSharePointContext(HttpContext);
using (var clientContext = spContext.CreateUserClientContextForSPHost())
{
if (clientContext != null)
{
Web web = clientContext.Web;
clientContext.Load(web, w => w.ContentTypes, w => w.Fields);
clientContext.ExecuteQuery();
foreach (ContentType ct in web.ContentTypes)
{
//find out documentset and child content type
if (ct.Name.IndexOf("document set", StringComparison.CurrentCultureIgnoreCase) != -1 ||
DocumentSetTemplate.IsChildOfDocumentSetContentType(clientContext, ct).Value)
{
template = DocumentSetTemplate.GetDocumentSetTemplate(clientContext, ct);
clientContext.Load(template, t => t.AllowedContentTypes, t => t.DefaultDocuments, t => t.SharedFields, t => t.WelcomePageFields);
clientContext.ExecuteQuery();
List <ContentTypeId> delList = new List <ContentTypeId>();
foreach (ContentTypeId ctId in template.AllowedContentTypes)
{
delList.Add(ctId);
}
//remove recorded content type id from allowedContentTypes list.
delList.ForEach(ctId => template.AllowedContentTypes.Remove(ctId));
break;
}
}
}
}
return(RedirectToAction("Index", new { SPHostUrl = SharePointContext.GetSPHostUrl(HttpContext.Request).AbsoluteUri }));
}
private void CreateContentTypes(SPWeb web)
{
//Create the EntityPart ContentType.
var documentStoreEntityPartContentTypeId = new SPContentTypeId(Constants.DocumentStoreEntityPartContentTypeId);
var documentStoreEntityPartContentTypeBestMatchId =
web.ContentTypes.BestMatch(documentStoreEntityPartContentTypeId);
var documentStoreEntityPartContentType = web.ContentTypes[documentStoreEntityPartContentTypeBestMatchId];
if (documentStoreEntityPartContentType == null)
{
documentStoreEntityPartContentType = new SPContentType(documentStoreEntityPartContentTypeId, web.ContentTypes, "Document Store Entity Part")
{
Group = "Document Store Content Types",
Description = "Represents additional data that is contained within a Document Store Entity."
};
//Add field links.
var categoryField = web.AvailableFields[Constants.CategoryFieldId];
var categoryFieldLink = new SPFieldLink(categoryField)
{
DisplayName = "Category",
ShowInDisplayForm = true,
ReadOnly = false
};
documentStoreEntityPartContentType.FieldLinks.Add(categoryFieldLink);
var commentField = web.AvailableFields[Constants.CommentFieldId];
var commentFieldLink = new SPFieldLink(commentField)
{
DisplayName = "Comments",
ShowInDisplayForm = true,
ReadOnly = false
};
documentStoreEntityPartContentType.FieldLinks.Add(commentFieldLink);
var documentEntityGuidField = web.AvailableFields[Constants.DocumentEntityGuidFieldId];
var documentEntityGuidFieldLink = new SPFieldLink(documentEntityGuidField)
{
DisplayName = "DocumentEntityGuid",
ShowInDisplayForm = false,
ReadOnly = true,
Required = false
};
documentStoreEntityPartContentType.FieldLinks.Add(documentEntityGuidFieldLink);
web.ContentTypes.Add(documentStoreEntityPartContentType);
documentStoreEntityPartContentType.Update(true);
}
//Create the Document Store Attachment ContentType.
var documentStoreAttachmentContentTypeId = new SPContentTypeId(Constants.DocumentStoreEntityAttachmentContentTypeId);
var documentStoreAttachmentContentTypeBestMatchId =
web.ContentTypes.BestMatch(documentStoreAttachmentContentTypeId);
var documentStoreAttachmentContentType = web.ContentTypes[documentStoreAttachmentContentTypeBestMatchId];
if (documentStoreAttachmentContentType == null)
{
documentStoreAttachmentContentType = new SPContentType(documentStoreAttachmentContentTypeId, web.ContentTypes, "Document Store Attachment")
{
Group = "Document Store Content Types",
Description = "Represents a document that is contained within a Document Store Entity."
};
//Add field links.
var categoryField = web.AvailableFields[Constants.CategoryFieldId];
var categoryFieldLink = new SPFieldLink(categoryField)
{
DisplayName = "Category",
ShowInDisplayForm = true,
ReadOnly = false
};
documentStoreAttachmentContentType.FieldLinks.Add(categoryFieldLink);
var commentField = web.AvailableFields[Constants.CommentFieldId];
var commentFieldLink = new SPFieldLink(commentField)
{
DisplayName = "Comments",
ShowInDisplayForm = true,
ReadOnly = false
};
documentStoreAttachmentContentType.FieldLinks.Add(commentFieldLink);
var pathField = web.AvailableFields[Constants.AttachmentPathFieldId];
var pathFieldLink = new SPFieldLink(pathField)
{
DisplayName = "Path",
ShowInDisplayForm = true,
ReadOnly = false
};
documentStoreAttachmentContentType.FieldLinks.Add(pathFieldLink);
var documentEntityGuidField = web.AvailableFields[Constants.DocumentEntityGuidFieldId];
var documentEntityGuidFieldLink = new SPFieldLink(documentEntityGuidField)
{
DisplayName = "DocumentEntityGuid",
ShowInDisplayForm = false,
ReadOnly = true,
Required = false
};
documentStoreAttachmentContentType.FieldLinks.Add(documentEntityGuidFieldLink);
web.ContentTypes.Add(documentStoreAttachmentContentType);
documentStoreAttachmentContentType.Update(true);
}
//Finally, create the DocumentStoreEntity ContentType which subclasses Document Set.
var documentStoreEntityContentTypeId = new SPContentTypeId(Constants.DocumentStoreEntityContentTypeId);
var documentStoreEntityContentTypeBestMatchId = web.ContentTypes.BestMatch(documentStoreEntityContentTypeId);
var documentStoreEntityContentType = web.ContentTypes[documentStoreEntityContentTypeBestMatchId];
if (documentStoreEntityContentType == null)
{
documentStoreEntityContentType = new SPContentType(documentStoreEntityContentTypeId,
web.ContentTypes, "Document Store Entity")
{
Group = "Document Store Content Types",
Description =
"Represents a document, attachments and associated metadata in a NoSql/Document-oriented database style model."
};
//Add field links.
var namespaceField = web.AvailableFields[Constants.NamespaceFieldId];
var namespaceFieldLink = new SPFieldLink(namespaceField);
documentStoreEntityContentType.FieldLinks.Add(namespaceFieldLink);
//TODO: Finish this...
web.ContentTypes.Add(documentStoreEntityContentType);
var documentStoreEntityTemplate = DocumentSetTemplate.GetDocumentSetTemplate(documentStoreEntityContentType);
documentStoreEntityTemplate.AllowedContentTypes.Add(documentStoreEntityPartContentTypeId);
}
}
public DocumentSetPipeBind(DocumentSetTemplate documentSetTemplate)
{
_documentSetTemplate = documentSetTemplate;
}
private HomeViewModel InitHomeViewModel()
{
DocumentSetTemplate template = null;
HomeViewModel model = new HomeViewModel();
User spUser = null;
var spContext = SharePointContextProvider.Current.GetSharePointContext(HttpContext);
using (var clientContext = spContext.CreateUserClientContextForSPHost())
{
if (clientContext != null)
{
spUser = clientContext.Web.CurrentUser;
clientContext.Load(spUser, user => user.Title);
clientContext.ExecuteQuery();
ViewBag.UserName = spUser.Title;
Web web = clientContext.Web;
clientContext.Load(web, w => w.ContentTypes, w => w.Fields);
clientContext.ExecuteQuery();
ContentType ctSow = web.ContentTypes.FirstOrDefault(ct => ct.Name == CONTENTTYPENAME);
if (ctSow != null)
{
template = DocumentSetTemplate.GetDocumentSetTemplate(clientContext, ctSow);
clientContext.Load(template, t => t.AllowedContentTypes, t => t.DefaultDocuments, t => t.SharedFields, t => t.WelcomePageFields);
clientContext.ExecuteQuery();
model.DocSetContentType = ctSow;
//template = GetDocumentSetTemplate(clientContext);
if (template != null)
{
foreach (ContentTypeId ctId in template.AllowedContentTypes)
{
ContentType ctAllowed = clientContext.Web.ContentTypes.First(d => d.StringId == ctId.StringValue);
if (ctAllowed != null)
{
model.AllowedContentTypes.Add(new ContentTypeModel()
{
Id = ctId, Name = ctAllowed.Name
});
}
}
foreach (Field field in template.SharedFields)
{
model.SharedFields.Add(new FieldModel()
{
Id = field.Id, Name = field.InternalName, Type = field.TypeDisplayName
});
}
foreach (Field field in template.WelcomePageFields)
{
model.WelcomeFields.Add(new FieldModel()
{
Id = field.Id, Name = field.InternalName, Type = field.TypeDisplayName
});
}
}
}
}
}
return(model);
}
public DocumentSetPipeBind(DocumentSetTemplate documentSetTemplate)
{
_documentSetTemplate = documentSetTemplate;
}
