protected void rptDelete_Click(object sender, EventArgs e)
{
LinkButton lnkDelete = (LinkButton)sender;
if (lnkDelete != null)
{
int deleteAttachmentIndex = ((RepeaterItem)lnkDelete.NamingContainer).ItemIndex;
string fileRelativeUrl = lnkDelete.CommandArgument.ToString();
using (var clientContext = GetClientContext())
{
if (clientContext != null)
{
Microsoft.SharePoint.Client.File fileToDelete = clientContext.Web.GetFileByServerRelativeUrl(fileRelativeUrl);
clientContext.Load(fileToDelete);
fileToDelete.DeleteObject();
clientContext.ExecuteQuery();
DataTable tblAattachments = GetAttachmentsFromRepeaterControl();
tblAattachments.Rows[deleteAttachmentIndex].Delete();
rptUploadedFiles.DataSource = tblAattachments;
rptUploadedFiles.DataBind();
} // if (clientContext != null)
} // using (var clientContext = GetClientContext())
} // if (lnkDelete != null)
} // protected void rptDelete_Click
/// <summary>
/// Deletes a file from the specified container
/// </summary>
/// <param name="fileName">Name of the file to delete</param>
/// <param name="container">Name of the container to delete the file from</param>
public override void DeleteFile(string fileName, string container)
{
try
{
using (ClientContext cc = GetClientContext().Clone(GetConnectionString()))
{
string fileServerRelativeUrl = GetFileServerRelativeUrl(cc, fileName, container);
File file = cc.Web.GetFileByServerRelativeUrl(fileServerRelativeUrl);
cc.Load(file);
cc.ExecuteQueryRetry();
if (file != null)
{
file.DeleteObject();
cc.ExecuteQueryRetry();
Log.Info(Constants.LOGGING_SOURCE, CoreResources.Provisioning_Connectors_SharePoint_FileDeleted, fileName, GetConnectionString(), container);
}
else
{
Log.Warning(Constants.LOGGING_SOURCE, CoreResources.Provisioning_Connectors_SharePoint_FileDeleteNotFound, fileName, GetConnectionString(), container);
}
}
}
catch (Exception ex)
{
Log.Error(Constants.LOGGING_SOURCE, CoreResources.Provisioning_Connectors_SharePoint_FileDeleteFailed, fileName, GetConnectionString(), container, ex.Message);
throw;
}
}
public JsonResult DeleteAttachment(string fileRelativeUrl)
{
try
{
SharePointContext spContext = Session["Context"] as SharePointContext;
if (spContext == null)
{
spContext = SharePointContextProvider.Current.GetSharePointContext(HttpContext);
}
using (var clientContext = spContext.CreateUserClientContextForSPHost())
{
if (clientContext != null)
{
Microsoft.SharePoint.Client.File fileToDelete = clientContext.Web.GetFileByServerRelativeUrl(fileRelativeUrl);
clientContext.Load(fileToDelete);
fileToDelete.DeleteObject();
clientContext.ExecuteQuery();
}
}
}
catch (Exception ex)
{
throw new Exception(ex.Message + "\n" + ex.StackTrace);
}
return(Json("Attachment Deleted"));
} // public void DeleteAttachment
public static void DeleteFile(this Web site, string fileServerRelativeUrl)
{
File file = site.GetFileByServerRelativeUrl(fileServerRelativeUrl);
file.DeleteObject();
site.Context.ExecuteQuery();
}
public void CanUploadHtmlPageLayoutAndConvertItToAspxVersionTest()
{
var web = pageLayoutTestWeb;
web.Context.Load(web);
// First delete the published file (if any) to avoid running into to many minor versions error with automated testing
List masterPageGallery = web.GetCatalog((int)ListTemplateType.MasterPageCatalog);
Folder rootFolder = masterPageGallery.RootFolder;
web.Context.Load(masterPageGallery);
web.Context.Load(rootFolder);
web.Context.ExecuteQueryRetry();
Microsoft.SharePoint.Client.File htmlPublishLayout = rootFolder.GetFile(String.Format("{0}.html", htmlPublishingPageWithoutExtension));
if (htmlPublishLayout != null)
{
htmlPublishLayout.DeleteObject();
web.Context.ExecuteQueryRetry();
}
web.DeployHtmlPageLayout(htmlPublishingPagePath, pageLayoutTitle, "", welcomePageContentTypeId);
web.Context.Load(web, w => w.ServerRelativeUrl);
web.Context.ExecuteQueryRetry();
var item = web.GetPageLayoutListItemByName(htmlPublishingPageWithoutExtension);
Assert.AreNotEqual(null, item);
}
private static bool DeleteDocument(string uri, string target, string fileName, string SharepointCountryCd, string GeographicRegionCd)
{
bool result = false;
try
{
ClientContext context = new ClientContext(webUrl + GeographicRegionCd + @"/" + SharepointCountryCd);
Web web = context.Web;
//context.Credentials = new NetworkCredential(userName, passWord, domain);
CredentialCache cc = new CredentialCache();
cc.Add(new Uri(webUrl),
"NTLM", new NetworkCredential(userName, passWord, domain));
context.Credentials = cc;
context.AuthenticationMode = ClientAuthenticationMode.Default;
context.Load(web);
context.ExecuteQuery();
string finalUrl = @"/" + uri + target + @"/" + fileName;
Microsoft.SharePoint.Client.File loadUrl = web.GetFileByServerRelativeUrl(finalUrl);
loadUrl.DeleteObject();
context.ExecuteQuery();
result = true;
}
catch (Exception ex)
{
throw ex;
}
return(result);
}
private static void DeleteScript(ClientContext clientContext, string name)
{
File jsreportFile =
clientContext.Web.GetFileByServerRelativeUrl(clientContext.Site.ServerRelativeUrl + "/SiteAssets/" +
name);
clientContext.Load(jsreportFile);
jsreportFile.DeleteObject();
}
/// <summary>
/// Deletes a file from the specified container
/// </summary>
/// <param name="fileName">Name of the file to delete</param>
/// <param name="container">Name of the container to delete the file from</param>
public override void DeleteFile(string fileName, string container)
{
try
{
using (ClientContext cc = GetClientContext().Clone(GetConnectionString()))
{
List list = cc.Web.GetListByUrl(GetDocumentLibrary(container));
string folders = GetFolders(container);
Folder spFolder = null;
if (folders.Length == 0)
{
spFolder = list.RootFolder;
}
else
{
spFolder = list.RootFolder;
string[] parts = container.Split(new string[] { "/" }, StringSplitOptions.RemoveEmptyEntries);
for (int i = 1; i < parts.Length; i++)
{
spFolder = spFolder.ResolveSubFolder(parts[i]);
}
}
if (!spFolder.IsPropertyAvailable("ServerRelativeUrl"))
{
spFolder.Context.Load(spFolder, w => w.ServerRelativeUrl);
spFolder.Context.ExecuteQueryRetry();
}
var fileServerRelativeUrl = UrlUtility.Combine(spFolder.ServerRelativeUrl, fileName);
File file = cc.Web.GetFileByServerRelativeUrl(fileServerRelativeUrl);
cc.Load(file);
cc.ExecuteQueryRetry();
if (file != null)
{
file.DeleteObject();
cc.ExecuteQueryRetry();
Log.Info(Constants.LOGGING_SOURCE, CoreResources.Provisioning_Connectors_SharePoint_FileDeleted, fileName, GetConnectionString(), container);
}
else
{
Log.Warning(Constants.LOGGING_SOURCE, CoreResources.Provisioning_Connectors_SharePoint_FileDeleteNotFound, fileName, GetConnectionString(), container);
}
}
}
catch (Exception ex)
{
Log.Error(Constants.LOGGING_SOURCE, CoreResources.Provisioning_Connectors_SharePoint_FileDeleteFailed, fileName, GetConnectionString(), container, ex.Message);
throw;
}
}
/// <summary>
/// Deletes the page
/// </summary>
/// <param name="clientContext">Client Context</param>
/// <param name="pageUrl">Page URL</param>
public static void Delete(ClientContext clientContext, string pageUrl)
{
if (null != clientContext && !string.IsNullOrWhiteSpace(pageUrl))
{
Microsoft.SharePoint.Client.File clientFile = clientContext.Web.GetFileByServerRelativeUrl(pageUrl);
if (IsFileExists(clientContext, pageUrl))
{
clientFile.DeleteObject();
clientContext.ExecuteQuery();
}
}
}
public static void CreatePublishingPage(ClientContext clientContext, string pageName, string pagelayoutname, string url, string queryurl)
{
var publishingPageName = pageName + ".aspx";
Web web = clientContext.Web;
clientContext.Load(web);
List pages = web.Lists.GetByTitle("Pages");
clientContext.Load(pages.RootFolder, f => f.ServerRelativeUrl);
clientContext.ExecuteQuery();
Microsoft.SharePoint.Client.File file =
web.GetFileByServerRelativeUrl(pages.RootFolder.ServerRelativeUrl + "/" + pageName + ".aspx");
clientContext.Load(file, f => f.Exists);
clientContext.ExecuteQuery();
if (file.Exists)
{
file.DeleteObject();
clientContext.ExecuteQuery();
}
PublishingWeb publishingWeb = PublishingWeb.GetPublishingWeb(clientContext, web);
clientContext.Load(publishingWeb);
if (publishingWeb != null)
{
List publishingLayouts = clientContext.Site.RootWeb.Lists.GetByTitle("Master Page Gallery");
ListItemCollection allItems = publishingLayouts.GetItems(CamlQuery.CreateAllItemsQuery());
clientContext.Load(allItems, items => items.Include(item => item.DisplayName).Where(obj => obj.DisplayName == pagelayoutname));
clientContext.ExecuteQuery();
ListItem layout = allItems.Where(x => x.DisplayName == pagelayoutname).FirstOrDefault();
clientContext.Load(layout);
PublishingPageInformation publishingpageInfo = new PublishingPageInformation()
{
Name = publishingPageName,
PageLayoutListItem = layout,
};
PublishingPage publishingPage = publishingWeb.AddPublishingPage(publishingpageInfo);
publishingPage.ListItem.File.CheckIn(string.Empty, CheckinType.MajorCheckIn);
publishingPage.ListItem.File.Publish(string.Empty);
clientContext.ExecuteQuery();
}
SetSupportCaseContent(clientContext, "SupportCasesPage", url, queryurl);
}
/// <summary>
/// This function deletes a file from the designated folder in SharePoint.
///
/// Please refer to the checkForReqProps metod for required properties.
///
/// </summary>
/// <returns></returns>
public Boolean DeleteSPFile()
{
Boolean tmpRetVal = true;
ClientContext ctx = null;
Web tmpWeb = null;
String tmpRelPath = String.Empty;
Microsoft.SharePoint.Client.File tmpfile = null;
String tmpPropList = String.Empty;
try
{
tmpPropList = checkForReqProps("DeleteFile");
if (tmpPropList == String.Empty)
{
RetErrMessage = "The following Properties must be set: " + tmpPropList;
tmpRetVal = false;
}
else
{
ctx = new ClientContext(SPSiteURL);
tmpWeb = ctx.Web;
tmpRelPath = SPRelPath + "/" + SPFileName;
tmpRelPath = tmpRelPath.Replace(" ", "%20");
tmpfile = tmpWeb.GetFileByServerRelativeUrl(tmpRelPath);
ctx.Load(tmpfile);
tmpfile.DeleteObject();
ctx.ExecuteQuery();
tmpRetVal = true;
}
}
catch (Exception ex)
{
RetErrMessage = ex.Message;
tmpRetVal = false;
}
return(tmpRetVal);
}
public override TokenParser ProvisionObjects(Web web, ProvisioningTemplate template, TokenParser parser, ProvisioningTemplateApplyingInformation applyingInformation)
{
using (var scope = new PnPMonitoredScope(this.Name))
{
var context = web.Context as ClientContext;
web.EnsureProperties(w => w.ServerRelativeUrl, w => w.RootFolder.WelcomePage);
// Check if this is not a noscript site as we're not allowed to update some properties
bool isNoScriptSite = web.IsNoScriptSite();
foreach (var page in template.Pages)
{
var url = parser.ParseString(page.Url);
if (!url.ToLower().StartsWith(web.ServerRelativeUrl.ToLower()))
{
url = UrlUtility.Combine(web.ServerRelativeUrl, url);
}
var exists = true;
Microsoft.SharePoint.Client.File file = null;
try
{
file = web.GetFileByServerRelativeUrl(url);
web.Context.Load(file);
web.Context.ExecuteQueryRetry();
}
catch (ServerException ex)
{
if (ex.ServerErrorTypeName == "System.IO.FileNotFoundException")
{
exists = false;
}
}
if (exists)
{
if (page.Overwrite)
{
try
{
scope.LogDebug(CoreResources.Provisioning_ObjectHandlers_Pages_Overwriting_existing_page__0_, url);
// determine url of current home page
string welcomePageUrl = web.RootFolder.WelcomePage;
string welcomePageServerRelativeUrl = welcomePageUrl != null
? UrlUtility.Combine(web.ServerRelativeUrl, web.RootFolder.WelcomePage)
: null;
bool overwriteWelcomePage = string.Equals(url, welcomePageServerRelativeUrl, StringComparison.InvariantCultureIgnoreCase);
// temporarily reset home page so we can delete it
if (overwriteWelcomePage)
{
web.SetHomePage(string.Empty);
}
file.DeleteObject();
web.Context.ExecuteQueryRetry();
web.AddWikiPageByUrl(url);
if (page.Layout == WikiPageLayout.Custom)
{
web.AddLayoutToWikiPage(WikiPageLayout.OneColumn, url);
}
else
{
web.AddLayoutToWikiPage(page.Layout, url);
}
if (overwriteWelcomePage)
{
// restore welcome page to previous value
web.SetHomePage(welcomePageUrl);
}
}
catch (Exception ex)
{
scope.LogError(CoreResources.Provisioning_ObjectHandlers_Pages_Overwriting_existing_page__0__failed___1_____2_, url, ex.Message, ex.StackTrace);
}
}
}
else
{
try
{
scope.LogDebug(CoreResources.Provisioning_ObjectHandlers_Pages_Creating_new_page__0_, url);
web.AddWikiPageByUrl(url);
if (page.Layout == WikiPageLayout.Custom)
{
web.AddLayoutToWikiPage(WikiPageLayout.OneColumn, url);
}
else
{
web.AddLayoutToWikiPage(page.Layout, url);
}
}
catch (Exception ex)
{
scope.LogError(CoreResources.Provisioning_ObjectHandlers_Pages_Creating_new_page__0__failed___1_____2_, url, ex.Message, ex.StackTrace);
}
}
#pragma warning disable 618
if (page.WelcomePage)
#pragma warning restore 618
{
web.RootFolder.EnsureProperty(p => p.ServerRelativeUrl);
var rootFolderRelativeUrl = url.Substring(web.RootFolder.ServerRelativeUrl.Length);
web.SetHomePage(rootFolderRelativeUrl);
}
#if !SP2013
bool webPartsNeedLocalization = false;
#endif
if (page.WebParts != null && page.WebParts.Any())
{
if (!isNoScriptSite)
{
var existingWebParts = web.GetWebParts(url);
foreach (var webPart in page.WebParts)
{
if (existingWebParts.FirstOrDefault(w => w.WebPart.Title == parser.ParseString(webPart.Title)) == null)
{
WebPartEntity wpEntity = new WebPartEntity
{
WebPartTitle = parser.ParseString(webPart.Title),
WebPartXml = parser.ParseXmlStringWebpart(webPart.Contents.Trim(new[] { '\n', ' ' }), web)
};
var wpd = web.AddWebPartToWikiPage(url, wpEntity, (int)webPart.Row, (int)webPart.Column, false);
#if !SP2013
if (webPart.Title.ContainsResourceToken())
{
// update data based on where it was added - needed in order to localize wp title
wpd.EnsureProperties(w => w.ZoneId, w => w.WebPart, w => w.WebPart.Properties);
webPart.Zone = wpd.ZoneId;
webPart.Order = (uint)wpd.WebPart.ZoneIndex;
webPartsNeedLocalization = true;
}
#endif
}
}
// Remove any existing WebPartIdToken tokens in the parser that were added by other pages. They won't apply to this page,
// and they'll cause issues if this page contains web parts with the same name as web parts on other pages.
parser.Tokens.RemoveAll(t => t is WebPartIdToken);
var allWebParts = web.GetWebParts(url);
foreach (var webpart in allWebParts)
{
parser.AddToken(new WebPartIdToken(web, webpart.WebPart.Title, webpart.Id));
}
}
else
{
scope.LogWarning(CoreResources.Provisioning_ObjectHandlers_Pages_SkipAddingWebParts, page.Url);
}
}
#if !SP2013
if (webPartsNeedLocalization)
{
page.LocalizeWebParts(web, parser, scope);
}
#endif
file = web.GetFileByServerRelativeUrl(url);
file.EnsureProperty(f => f.ListItemAllFields);
if (page.Fields.Any())
{
var item = file.ListItemAllFields;
foreach (var fieldValue in page.Fields)
{
item[fieldValue.Key] = parser.ParseString(fieldValue.Value);
}
item.Update();
web.Context.ExecuteQueryRetry();
}
if (page.Security != null && page.Security.RoleAssignments.Count != 0)
{
web.Context.Load(file.ListItemAllFields);
web.Context.ExecuteQueryRetry();
file.ListItemAllFields.SetSecurity(parser, page.Security, WriteMessage);
}
}
}
return(parser);
}
public void CleanUp()
{
Console.WriteLine("BrandingExtensionsTests.CleanUp");
if (System.IO.File.Exists(customColorFilePath))
{
System.IO.File.Delete(customColorFilePath);
}
if (System.IO.File.Exists(customBackgroundFilePath))
{
System.IO.File.Delete(customBackgroundFilePath);
}
using (var context = TestCommon.CreateClientContext())
{
var web = context.Web;
// Remove composed looks from server
List themeGallery = web.GetCatalog((int)ListTemplateType.DesignCatalog);
CamlQuery query = new CamlQuery();
string camlString = @"
<View>
<Query>
<Where>
<Contains>
<FieldRef Name='Name' />
<Value Type='Text'>Test_</Value>
</Contains>
</Where>
</Query>
</View>";
query.ViewXml = camlString;
var found = themeGallery.GetItems(query);
web.Context.Load(found);
web.Context.ExecuteQueryRetry();
Console.WriteLine("{0} matching looks found to delete", found.Count);
var looksToDelete = found.ToList();
foreach (var item in looksToDelete)
{
Console.WriteLine("Delete look item '{0}'", item["Name"]);
item.DeleteObject();
context.ExecuteQueryRetry();
}
// Remove Theme Files
List themesList = web.GetCatalog((int)ListTemplateType.ThemeCatalog);
Folder rootFolder = themesList.RootFolder;
FolderCollection rootFolders = rootFolder.Folders;
web.Context.Load(rootFolder);
web.Context.Load(rootFolders, f => f.Where(folder => folder.Name == "15"));
web.Context.ExecuteQueryRetry();
Folder folder15 = rootFolders.FirstOrDefault();
try
{
Microsoft.SharePoint.Client.File customColorFile = folder15.Files.GetByUrl("custom.spcolor");
customColorFile.DeleteObject();
context.ExecuteQueryRetry();
}
catch (Exception ex)
{
Console.WriteLine("Exception cleaning up: {0}", ex);
}
try
{
Microsoft.SharePoint.Client.File customBackgroundFile = folder15.Files.GetByUrl("custombg.jpg");
customBackgroundFile.DeleteObject();
context.ExecuteQueryRetry();
}
catch (Exception ex)
{
Console.WriteLine("Exception cleaning up: {0}", ex);
}
// Remove webs
var webCollection1 = web.Webs;
context.Load(webCollection1, wc => wc.Include(w => w.Title, w => w.ServerRelativeUrl));
context.ExecuteQueryRetry();
var websToDelete = new List <Web>();
foreach (var web1 in webCollection1)
{
if (web1.Title.StartsWith("Test_"))
{
var webCollection2 = web1.Webs;
context.Load(webCollection2, wc => wc.Include(w => w.Title, w => w.ServerRelativeUrl));
context.ExecuteQueryRetry();
var childrenToDelete = new List <Web>(webCollection2);
foreach (var web2 in childrenToDelete)
{
Console.WriteLine("Deleting site {0}", web2.ServerRelativeUrl);
web2.DeleteObject();
context.ExecuteQueryRetry();
}
websToDelete.Add(web1);
}
}
foreach (var web1 in websToDelete)
{
Console.WriteLine("Deleting site {0}", web1.ServerRelativeUrl);
web1.DeleteObject();
try
{
context.ExecuteQueryRetry();
}
catch (Exception ex)
{
Console.WriteLine("Exception cleaning up: {0}", ex);
}
}
// Remove pagelayouts
List masterPageGallery = context.Web.GetCatalog((int)ListTemplateType.MasterPageCatalog);
Folder rootFolderInMasterPageGallery = masterPageGallery.RootFolder;
context.Load(rootFolderInMasterPageGallery, f => f.ServerRelativeUrl);
context.ExecuteQueryRetry();
try
{
var fileServerRelativeUrl = UrlUtility.Combine(rootFolderInMasterPageGallery.ServerRelativeUrl, publishingPageWithoutExtension);
var file = context.Web.GetFileByServerRelativeUrl(String.Format("{0}.aspx", fileServerRelativeUrl));
context.Load(file);
context.ExecuteQueryRetry();
file.DeleteObject();
context.ExecuteQueryRetry();
fileServerRelativeUrl = UrlUtility.Combine(rootFolderInMasterPageGallery.ServerRelativeUrl, "test/test", publishingPageWithoutExtension);
file = context.Web.GetFileByServerRelativeUrl(String.Format("{0}.aspx", fileServerRelativeUrl));
context.Load(file);
context.ExecuteQueryRetry();
file.DeleteObject();
context.ExecuteQueryRetry();
}
catch (Exception ex)
{
Console.WriteLine("Exception cleaning up: {0}", ex);
}
}
Teardown();
}
public override TokenParser ProvisionObjects(Web web, ProvisioningTemplate template, TokenParser parser, ProvisioningTemplateApplyingInformation applyingInformation)
{
using (var scope = new PnPMonitoredScope(this.Name))
{
var context = web.Context as ClientContext;
PublishingWeb webPub = PublishingWeb.GetPublishingWeb(context, web);
context.Load(webPub);
//context.ExecuteQuery();
web.EnsureProperties(w => w.ServerRelativeUrl, w => w.RootFolder.WelcomePage, w => w.AllProperties);
if (!web.IsPublishingWeb())
{
throw new Exception(String.Format("Site '{0}' is not a publishing site", web.ServerRelativeUrl));
}
// Get Publishing Page Layouts
List publishingLayouts = context.Site.RootWeb.GetCatalog((int)ListTemplateType.MasterPageCatalog);
ListItemCollection allPageLayouts = publishingLayouts.GetItems(CamlQuery.CreateAllItemsQuery());
context.Load(allPageLayouts, items => items.Include(item => item.DisplayName, item => item["Title"]));
context.ExecuteQuery();
if (webPub != null)
{
foreach (var page in template.PublishingPages)
{
var name = parser.ParseString(page.Name);
if (!name.ToLower().EndsWith(".aspx"))
{
name = String.Format("{0}{1}", name, ".aspx");
}
page.Name = name;
var exists = true;
string urlFile = string.Empty;
Microsoft.SharePoint.Client.File file = null;
try
{
urlFile = UrlUtility.Combine(web.ServerRelativeUrl, new[] { "Pages", page.Name });
file = web.GetFileByServerRelativeUrl(urlFile);
web.Context.Load(file);
web.Context.ExecuteQuery();
}
catch (ServerException ex)
{
if (ex.ServerErrorTypeName == "System.IO.FileNotFoundException")
{
exists = false;
}
}
if (exists)
{
if (page.Overwrite)
{
//delete page
if (web.RootFolder.WelcomePage.Contains(page.Name))
{
web.SetHomePage(string.Empty);
}
file.DeleteObject();
web.Context.ExecuteQueryRetry();
try
{
AddPublishingPage(context, webPub, allPageLayouts, page);
}
catch (Exception ex)
{
scope.LogError(CoreResources.Provisioning_ObjectHandlers_Pages_Overwriting_existing_page__0__failed___1_____2_, name, ex.Message, ex.StackTrace);
}
}
}
else
{
//Create Page
try
{
AddPublishingPage(context, webPub, allPageLayouts, page);
}
catch (Exception ex)
{
scope.LogError(CoreResources.Provisioning_ObjectHandlers_Pages_Overwriting_existing_page__0__failed___1_____2_, name, ex.Message, ex.StackTrace);
}
}
if (page.WebParts != null & page.WebParts.Any())
{
var existingWebParts = web.GetWebParts(urlFile);
foreach (var webpart in page.WebParts)
{
if (existingWebParts.FirstOrDefault(w => w.WebPart.Title == webpart.Title) == null)
{
WebPartEntity wpEntity = new WebPartEntity();
wpEntity.WebPartTitle = webpart.Title;
wpEntity.WebPartXml = parser.ParseString(webpart.Contents.Trim(new[] { '\n', ' ' }));
wpEntity.WebPartZone = webpart.Zone;
wpEntity.WebPartIndex = (int)webpart.Order;
web.AddWebPartToWebPartPage(urlFile, wpEntity);
}
}
var allWebParts = web.GetWebParts(urlFile);
foreach (var webpart in allWebParts)
{
parser.AddToken(new WebPartIdToken(web, webpart.WebPart.Title, webpart.Id));
}
}
CheckInAndPublishPage(context, webPub, urlFile);
}
}
}
return(parser);
}
public override void ProvisionObjects(Web web, ProvisioningTemplate template)
{
Log.Info(Constants.LOGGING_SOURCE_FRAMEWORK_PROVISIONING, CoreResources.Provisioning_ObjectHandlers_Pages);
var context = web.Context as ClientContext;
if (!web.IsPropertyAvailable("ServerRelativeUrl"))
{
context.Load(web, w => w.ServerRelativeUrl);
context.ExecuteQueryRetry();
}
foreach (var page in template.PublishingPages)
{
var url = String.Format("{0}/Pages/{1}.aspx", web.ServerRelativeUrl, page.PageName);
if (!url.ToLower().StartsWith(web.ServerRelativeUrl.ToLower()))
{
url = UrlUtility.Combine(web.ServerRelativeUrl, url);
}
var exists = true;
Microsoft.SharePoint.Client.File file = null;
try
{
file = web.GetFileByServerRelativeUrl(url);
web.Context.Load(file);
web.Context.ExecuteQuery();
}
catch (ServerException ex)
{
if (ex.ServerErrorTypeName == "System.IO.FileNotFoundException")
{
exists = false;
}
}
if (exists)
{
if (page.Overwrite)
{
file.DeleteObject();
web.Context.ExecuteQueryRetry();
web.AddPublishingPage(page.PageName, page.PageLayoutName, page.Title, page.Content, page.Properties, page.Publish);
}
//if (file.CheckOutType == CheckOutType.None)
//{
// file.CheckOut();
//}
}
else
{
web.AddPublishingPage(page.PageName, page.PageLayoutName, page.Title, page.Content, page.Properties, page.Publish);
}
if (page.WelcomePage)
{
if (!web.IsPropertyAvailable("RootFolder"))
{
web.Context.Load(web.RootFolder);
web.Context.ExecuteQueryRetry();
}
var rootFolderRelativeUrl = url.Substring(web.RootFolder.ServerRelativeUrl.Length);
web.SetHomePage(rootFolderRelativeUrl);
}
// Check out the file if needed
if (page.WebParts != null & page.WebParts.Any())
{
if (!exists)
{
file = web.GetFileByServerRelativeUrl(url);
web.Context.Load(file);
web.Context.ExecuteQuery();
}
file.CheckOut();
var existingWebParts = web.GetWebParts(url);
foreach (var webpart in page.WebParts)
{
if (existingWebParts.FirstOrDefault(w => w.WebPart.Title == webpart.Title) == null)
{
WebPartEntity wpEntity = new WebPartEntity();
wpEntity.WebPartTitle = webpart.Title;
wpEntity.WebPartIndex = (int)webpart.Order;
wpEntity.WebPartZone = webpart.Zone;
if (!string.IsNullOrWhiteSpace(webpart.ListUrl))
{
var list = web.GetListByUrl(webpart.ListUrl);
var contents = String.Format(webpart.Contents, list.Id, list.Title);
wpEntity.WebPartXml = contents.Trim(new[] { '\n', ' ' });
}
else
{
wpEntity.WebPartXml = webpart.Contents.ToParsedString().Trim(new[] { '\n', ' ' });
}
//wpEntity.WebPartXml = webpart.Contents.ToParsedString().Trim(new[] {'\n', ' '});
web.AddWebPartToWebPartPage(url, wpEntity);
}
}
file.CheckIn("", CheckinType.MajorCheckIn);
file.Publish("");
}
}
}
public override void ProvisionObjects(Web web, ProvisioningTemplate template, ProvisioningTemplateApplyingInformation applyingInformation)
{
Log.Info(Constants.LOGGING_SOURCE_FRAMEWORK_PROVISIONING, CoreResources.Provisioning_ObjectHandlers_Pages);
var context = web.Context as ClientContext;
if (!web.IsPropertyAvailable("ServerRelativeUrl"))
{
context.Load(web, w => w.ServerRelativeUrl);
context.ExecuteQueryRetry();
}
foreach (var page in template.Pages)
{
var url = page.Url.ToParsedString();
if (!url.ToLower().StartsWith(web.ServerRelativeUrl.ToLower()))
{
url = UrlUtility.Combine(web.ServerRelativeUrl, url);
}
var exists = true;
Microsoft.SharePoint.Client.File file = null;
try
{
file = web.GetFileByServerRelativeUrl(url);
web.Context.Load(file);
web.Context.ExecuteQuery();
}
catch (ServerException ex)
{
if (ex.ServerErrorTypeName == "System.IO.FileNotFoundException")
{
exists = false;
}
}
if (exists)
{
if (page.Overwrite)
{
file.DeleteObject();
web.Context.ExecuteQueryRetry();
web.AddWikiPageByUrl(url);
web.AddLayoutToWikiPage(page.Layout, url);
}
}
else
{
web.AddWikiPageByUrl(url);
web.AddLayoutToWikiPage(page.Layout, url);
}
if (page.WelcomePage)
{
if (!web.IsPropertyAvailable("RootFolder"))
{
web.Context.Load(web.RootFolder);
web.Context.ExecuteQueryRetry();
}
var rootFolderRelativeUrl = url.Substring(web.RootFolder.ServerRelativeUrl.Length);
web.SetHomePage(rootFolderRelativeUrl);
}
if (page.WebParts != null & page.WebParts.Any())
{
var existingWebParts = web.GetWebParts(url);
foreach (var webpart in page.WebParts)
{
if (existingWebParts.FirstOrDefault(w => w.WebPart.Title == webpart.Title) == null)
{
WebPartEntity wpEntity = new WebPartEntity();
wpEntity.WebPartTitle = webpart.Title;
wpEntity.WebPartXml = webpart.Contents.ToParsedString().Trim(new[] { '\n', ' ' });
web.AddWebPartToWikiPage(url, wpEntity, (int)webpart.Row, (int)webpart.Column, false);
}
}
}
}
}
public override TokenParser ProvisionObjects(Web web, ProvisioningTemplate template, TokenParser parser, ProvisioningTemplateApplyingInformation applyingInformation)
{
using (var scope = new PnPMonitoredScope(this.Name))
{
var context = web.Context as ClientContext;
web.EnsureProperties(w => w.ServerRelativeUrl, w => w.RootFolder.WelcomePage);
foreach (var page in template.Pages)
{
var url = parser.ParseString(page.Url);
if (!url.ToLower().StartsWith(web.ServerRelativeUrl.ToLower()))
{
url = UrlUtility.Combine(web.ServerRelativeUrl, url);
}
var exists = true;
Microsoft.SharePoint.Client.File file = null;
try
{
file = web.GetFileByServerRelativeUrl(url);
web.Context.Load(file);
web.Context.ExecuteQuery();
}
catch (ServerException ex)
{
if (ex.ServerErrorTypeName == "System.IO.FileNotFoundException")
{
exists = false;
}
}
if (exists)
{
if (page.Overwrite)
{
try
{
scope.LogDebug(CoreResources.Provisioning_ObjectHandlers_Pages_Overwriting_existing_page__0_, url);
if (page.WelcomePage && url.Contains(web.RootFolder.WelcomePage))
{
web.SetHomePage(string.Empty);
}
file.DeleteObject();
web.Context.ExecuteQueryRetry();
web.AddWikiPageByUrl(url);
web.AddLayoutToWikiPage(page.Layout, url);
}
catch (Exception ex)
{
scope.LogError(CoreResources.Provisioning_ObjectHandlers_Pages_Overwriting_existing_page__0__failed___1_____2_, url, ex.Message, ex.StackTrace);
}
}
}
else
{
try
{
scope.LogDebug(CoreResources.Provisioning_ObjectHandlers_Pages_Creating_new_page__0_, url);
web.AddWikiPageByUrl(url);
web.AddLayoutToWikiPage(page.Layout, url);
}
catch (Exception ex)
{
scope.LogError(CoreResources.Provisioning_ObjectHandlers_Pages_Creating_new_page__0__failed___1_____2_, url, ex.Message, ex.StackTrace);
}
}
if (page.WelcomePage)
{
web.RootFolder.EnsureProperty(p => p.ServerRelativeUrl);
var rootFolderRelativeUrl = url.Substring(web.RootFolder.ServerRelativeUrl.Length);
web.SetHomePage(rootFolderRelativeUrl);
}
if (page.WebParts != null & page.WebParts.Any())
{
var existingWebParts = web.GetWebParts(url);
foreach (var webpart in page.WebParts)
{
if (existingWebParts.FirstOrDefault(w => w.WebPart.Title == webpart.Title) == null)
{
WebPartEntity wpEntity = new WebPartEntity();
wpEntity.WebPartTitle = webpart.Title;
wpEntity.WebPartXml = parser.ParseString(webpart.Contents).Trim(new[] { '\n', ' ' });
web.AddWebPartToWikiPage(url, wpEntity, (int)webpart.Row, (int)webpart.Column, false);
}
}
}
if (page.Security != null && page.Security.RoleAssignments.Count != 0)
{
file = web.GetFileByServerRelativeUrl(url);
web.Context.Load(file.ListItemAllFields);
web.Context.ExecuteQuery();
file.ListItemAllFields.SetSecurity(parser, page.Security);
}
}
}
return(parser);
}
public static bool Move(string currentLCU,
string newLCU,
ModuleName moduleName,
int moduleId,
string geographicRegionCd,
string sharepointCountryCd,
string customerNbr,
string fileName,
string newGeographicRegionCd, string newSharepointCountryCd, string newCustomerNbr)
{
bool result = false;
var _region = geographicRegionCd;
var _country = sharepointCountryCd;
var clientNbr = customerNbr;
string region = string.Empty;
string newRegion = string.Empty;
StringBuilder finalUri = new StringBuilder("");
if (_region == "EL")
{
region = "EME";
}
if (_region == "AP")
{
region = "APA";
}
if (_region != "EL" && _region != "AP")
{
region = "AMR";
}
_region = newGeographicRegionCd;
if (_region == "EL")
{
newRegion = "EME";
}
if (_region == "AP")
{
newRegion = "APA";
}
if (_region != "EL" && _region != "AP")
{
newRegion = "AMR";
}
if (webUrl.Substring(webUrl.Length - 1, 1) != "/")
{
webUrl = webUrl + "/";
}
try
{
string uri = webUrl + region + @"/" + sharepointCountryCd;
string newUri = webUrl + newRegion + @"/" + newSharepointCountryCd;
var newClientContext = new ClientContext(newUri);
Web newWeb = newClientContext.Web;
//newClientContext.Credentials = new NetworkCredential(userName, passWord, domain);
CredentialCache cc = new CredentialCache();
cc.Add(new Uri(webUrl),
"NTLM", new NetworkCredential(userName, passWord, domain));
newClientContext.Credentials = cc;
newClientContext.AuthenticationMode = ClientAuthenticationMode.Default;
newClientContext.Load(newWeb);
newClientContext.ExecuteQuery();
using (ClientContext context = new ClientContext(uri))
{
Web web = context.Web;
//context.Credentials = new NetworkCredential(userName, passWord, domain);
CredentialCache ccs = new CredentialCache();
cc.Add(new Uri(webUrl),
"NTLM", new NetworkCredential(userName, passWord, domain));
context.Credentials = ccs;
context.AuthenticationMode = ClientAuthenticationMode.Default;
context.Load(web);
context.ExecuteQuery();
string destinationUrl = EnsureParentFolder(newLCU, moduleId.ToString(), moduleName, newGeographicRegionCd, newSharepointCountryCd, newCustomerNbr, newClientContext);
finalUri.Append("/sites");
finalUri.Append("/");
finalUri.Append(region);
finalUri.Append("/");
finalUri.Append(sharepointCountryCd);
finalUri.Append("/");
finalUri.Append(docLib);
finalUri.Append("/");
finalUri.Append(clientNbr);
finalUri.Append("/");
finalUri.Append(currentLCU);
finalUri.Append("/");
finalUri.Append(moduleName.ToString());
finalUri.Append("/");
finalUri.Append(moduleId);
finalUri.Append("/");
string destUrl = finalUri.ToString() + fileName;
Microsoft.SharePoint.Client.File loadUrl = web.GetFileByServerRelativeUrl(destUrl);
if (region == newRegion)
{
loadUrl.MoveTo(destinationUrl + fileName, MoveOperations.Overwrite);
context.ExecuteQuery();
result = true;
}
if (region != newRegion)
{
var setMetadata = loadUrl.ListItemAllFields;
context.Load(setMetadata);
context.ExecuteQuery();
SharePointMetaData spModel = new SharePointMetaData();
spModel.operatingGrpCode = (string)setMetadata["OperatingGroupCd"];
spModel.operatingGrp = (string)setMetadata["OperatingGroupNm"];
spModel.operatingUnitCode = (string)setMetadata["OperatingUnitCd"];
spModel.operatingUnit = (string)setMetadata["OperatingUnitNm"];
spModel.clientServiceGrpCode = (string)setMetadata["OperatingUnitNm"];
spModel.clientServiceGrp = (string)setMetadata["ClientServiceGroupDesc"];
spModel.clientName = (string)setMetadata["CustomerNm"];
spModel.clientNumber = (string)setMetadata["CustomerNbr"];
spModel.contractNumber = (string)setMetadata["ContractNbr"];
spModel.strLCUId = (string)setMetadata["LCUId"];
spModel.moduleName = (string)setMetadata["ModuleNm"];
spModel.moduleId = (string)setMetadata["ModuleId"];
spModel.userId = (string)setMetadata["UserId"];
spModel.fileTypeCode = (string)setMetadata["FileTypeCd"];
spModel.fileType = (string)setMetadata["FileTypeNm"];
spModel.documentTypeCode = (string)setMetadata["DocumentTypeCd"];
spModel.documentType = (string)setMetadata["DocumentTypeNm"];
spModel.documentName = (string)setMetadata["DocumentNm"];
string newDestUrl = destinationUrl + fileName;
FileInformation loadStream = Microsoft.SharePoint.Client.File.OpenBinaryDirect(context, destUrl);
Microsoft.SharePoint.Client.File.SaveBinaryDirect(newClientContext, destinationUrl + fileName, loadStream.Stream, true);
SetMeta(spModel, newUri, newDestUrl);
loadUrl.DeleteObject();
context.ExecuteQuery();
result = true;
}
}
}
catch (Exception ex)
{
throw ex;
}
return(result);
}
