| public static LogSuccessMessage ( string msg, bool toConsole = true ) : void | ||
| msg | string | |
| toConsole | bool | |
| return | void | |
public static void SetMasterPages(Web web, MasterPageInfo mpi, bool isRoot)
{
try
{
Logger.LogInfoMessage(String.Format("Setting Master Pages to: {0} & {1}...", mpi.MasterPageUrl, mpi.CustomMasterPageUrl), false);
Logger.LogInfoMessage(String.Format("MasterUrl (before): {0}", web.MasterUrl), false);
Logger.LogInfoMessage(String.Format("CustomMasterUrl (before): {0}", web.CustomMasterUrl), false);
web.Context.Load(web.AllProperties);
web.Context.ExecuteQuery();
web.MasterUrl = mpi.MasterPageUrl;
web.CustomMasterUrl = mpi.CustomMasterPageUrl;
web.AllProperties[Constants.PropertyBagInheritMaster] = ((!isRoot && mpi.InheritMaster) ? "True" : "False");
web.AllProperties[Constants.PropertyBagInheritCustomMaster] = ((!isRoot && mpi.InheritCustomMaster) ? "True" : "False");
web.Update();
web.Context.ExecuteQuery();
Logger.LogSuccessMessage(String.Format("MasterUrl (after): {0}", web.MasterUrl), false);
Logger.LogSuccessMessage(String.Format("CustomMasterUrl (after): {0}", web.CustomMasterUrl), false);
}
catch (Exception ex)
{
Logger.LogErrorMessage(String.Format("SetMasterPages() failed for {0}: Error={1}", web.Url, ex.Message), false);
}
}
private static void ReportSiteColumnUsage(Web web, Guid siteColumnId, string siteColumnName)
{
if (web.FieldExistsById(siteColumnId) == true)
{
Logger.LogSuccessMessage(String.Format("FOUND: Site Column [{1}] on WEB: {0}", web.Url, siteColumnName), true);
}
}
/// <summary>
/// Deletes the specified file from the specified web.
/// </summary>
/// <param name="web">this MUST be the web that contains the file to delete</param>
/// <param name="serverRelativeFilePath">the SERVER-relative path to the file ("/sites/site/web/lib/folder/file.ext")</param>
public static void DeleteFileByServerRelativeUrl(Web web, string serverRelativeFilePath)
{
try
{
Logger.LogInfoMessage(String.Format("Deleting File: {0} ...", serverRelativeFilePath), false);
File targetFile = web.GetFileByServerRelativeUrl(serverRelativeFilePath);
web.Context.Load(targetFile);
web.Context.ExecuteQuery();
if (targetFile.ServerObjectIsNull == false)
{
targetFile.DeleteObject();
web.Context.ExecuteQuery();
Logger.LogSuccessMessage(String.Format("Deleted File: {0}", serverRelativeFilePath), false);
}
else
{
Logger.LogErrorMessage(String.Format("DeleteFileByServerRelativeUrl() failed for {0}: Error={1}", serverRelativeFilePath, "File was not Found."), false);
}
}
catch (ServerException ex)
{
Logger.LogErrorMessage(String.Format("DeleteFileByServerRelativeUrl() failed for {0}: Error={1}", serverRelativeFilePath, ex.Message), false);
}
catch (Exception ex)
{
Logger.LogErrorMessage(String.Format("DeleteFileByServerRelativeUrl() failed for {0}: Error={1}", serverRelativeFilePath, ex.Message), false);
}
}
public static void DeleteListByUrl(Web web, string webRelativeUrl)
{
try
{
Logger.LogInfoMessage(String.Format("Deleting List {0} from {1} ...", webRelativeUrl, web.Url), false);
List targetList = web.GetListByUrl(webRelativeUrl);
if (targetList != null && targetList.ServerObjectIsNull == false)
{
targetList.DeleteObject();
web.Context.ExecuteQuery();
Logger.LogSuccessMessage(String.Format("Deleted List {0} from {1}", webRelativeUrl, web.Url), false);
}
else
{
Logger.LogErrorMessage(String.Format("DeleteListByUrl() failed for {0}: Error=List {1} was not found", web.Url, webRelativeUrl), false);
}
}
catch (ServerException ex)
{
if (ex.ServerErrorTypeName.Equals("System.IO.FileNotFoundException", StringComparison.InvariantCultureIgnoreCase) == false)
{
Logger.LogErrorMessage(String.Format("DeleteListByUrl() failed for {0}: Error={1}", web.Url, ex.Message), false);
}
}
catch (Exception ex)
{
Logger.LogErrorMessage(String.Format("DeleteListByUrl() failed for {0}: Error={1}", web.Url, ex.Message), false);
}
}
private static void ReportSiteColumnUsage(Web web, List list, Guid siteColumnId, string siteColumnName)
{
if (list.FieldExistsById(siteColumnId) == true)
{
Logger.LogSuccessMessage(String.Format("FOUND: Site Column [{2}] on LIST [{0}] of WEB: {1}", list.Title, web.Url, siteColumnName), true);
}
}
public static string PublishMasterPage(Web web, string mpFilePath, string title, string description)
{
try
{
Logger.LogInfoMessage(String.Format("Publishing Master Page File: {0} ...", mpFilePath), false);
List mpGallery = web.GetCatalog((int)ListTemplateType.MasterPageCatalog);
Folder mpGalleryRoot = mpGallery.RootFolder;
web.Context.Load(mpGallery);
web.Context.Load(mpGalleryRoot);
web.Context.ExecuteQuery();
File mpFile = GetFileFromWeb(web, mpFilePath);
if (mpFile == null)
{
Logger.LogErrorMessage(String.Format("UploadMasterPage() failed for {0}: Error=File Not Found", web.Url), false);
return(String.Empty);
}
if (mpGallery.ForceCheckout || mpGallery.EnableVersioning)
{
if (mpFile.CheckOutType == CheckOutType.None)
{
mpFile.CheckOut();
}
}
ListItem fileListItem = mpFile.ListItemAllFields;
fileListItem["MasterPageDescription"] = description;
fileListItem["UIVersion"] = "15";
if (mpGallery.AllowContentTypes && mpGallery.ContentTypesEnabled)
{
fileListItem["Title"] = title;
fileListItem["ContentTypeId"] = Constants.MASTERPAGE_CONTENT_TYPE;
}
fileListItem.Update();
if (mpGallery.ForceCheckout || mpGallery.EnableVersioning)
{
mpFile.CheckIn(string.Empty, CheckinType.MajorCheckIn);
if (mpGallery.EnableModeration)
{
mpFile.Approve("");
}
}
web.Context.ExecuteQuery();
Logger.LogSuccessMessage(String.Format("Published Master Page File: {0}", mpFile.ServerRelativeUrl), false);
return(mpFile.ServerRelativeUrl);
}
catch (Exception ex)
{
Logger.LogErrorMessage(String.Format("UploadMasterPage() failed for {0}: Error={1}", web.Url, ex.Message), false);
return(String.Empty);
}
}
public static string UploadDeviceChannelMappingFile(Web web, string serverRelativeMappingFilePath, string fileContents, string description)
{
try
{
Logger.LogInfoMessage(String.Format("Uploading Device Channel Mapping File: {0} ...", serverRelativeMappingFilePath), false);
// grab a reference to the MP Gallery where the device channel mapping file resides.
List mpGallery = web.GetCatalog((int)ListTemplateType.MasterPageCatalog);
Folder mpGalleryRoot = mpGallery.RootFolder;
web.Context.Load(mpGallery);
web.Context.Load(mpGalleryRoot);
web.Context.ExecuteQuery();
// get the file and check-out if necessary
File dcmFile = GetFileFromWeb(web, serverRelativeMappingFilePath);
if (dcmFile != null)
{
web.CheckOutFile(serverRelativeMappingFilePath);
}
// prepare the file contents for upload
Byte[] fileBytes = System.Text.Encoding.UTF8.GetBytes(fileContents);
// Use CSOM to upload the file
FileCreationInformation newFile = new FileCreationInformation();
newFile.Content = fileBytes;
newFile.Overwrite = true;
newFile.Url = serverRelativeMappingFilePath;
File uploadFile = mpGalleryRoot.Files.Add(newFile);
web.Context.Load(uploadFile);
web.Context.ExecuteQuery();
// check-in and approve as necessary
if (mpGallery.ForceCheckout || mpGallery.EnableVersioning)
{
web.CheckInFile(uploadFile.ServerRelativeUrl, CheckinType.MajorCheckIn, description);
if (mpGallery.EnableModeration)
{
web.ApproveFile(uploadFile.ServerRelativeUrl, description);
}
}
Logger.LogSuccessMessage(String.Format("Uploaded Device Channel Mapping File: {0}", uploadFile.ServerRelativeUrl), false);
return(uploadFile.ServerRelativeUrl);
}
catch (Exception ex)
{
Logger.LogErrorMessage(String.Format("UploadDeviceChannelMappingFile() failed for {0}: Error={1}", serverRelativeMappingFilePath, ex.Message), false);
return(String.Empty);
}
}
private static void ProcessInputFile(string masterPageInputFile, bool replaceMasterUrl, bool replaceCustomMasterUrl, bool replaceBothMaserUrls, string outputDirectory)
{
DataTable dtMasterPagesInput = new DataTable();
try
{
dtMasterPagesInput = ImportCSV.Read(masterPageInputFile, Constants.CsvDelimeter);
List <string> lstWebUrls = dtMasterPagesInput.AsEnumerable()
.Select(r => r.Field <string>("WebUrl"))
.ToList();
lstWebUrls = lstWebUrls.Distinct().ToList();
foreach (string webUrl in lstWebUrls)
{
string webApplicationUrl = string.Empty;
try
{
Logger.LogInfoMessage("[ReplaceMasterPage: ProcessInputFile] Processing the Site: " + webUrl, true);
if (ProcessWebUrl(webUrl, null, replaceMasterUrl, replaceCustomMasterUrl, replaceBothMaserUrls))
{
Logger.LogSuccessMessage("[ReplaceMasterPage:ProcessInputFile]successfully replaced master page for the site " + webUrl + " and output file is present in the path: " + outputDirectory, true);
}
else
{
Logger.LogErrorMessage("[ReplaceMasterPage: ProcessInputFile] Replacing Custom Master Page with OOB Master Page is failed for the site " + webUrl);
}
}
catch (Exception ex)
{
Logger.LogErrorMessage("[ReplaceMasterPage: ProcessInputFile]. Exception Message: " + ex.Message, true);
ExceptionCsv.WriteException(Constants.NotApplicable, Constants.NotApplicable, Constants.NotApplicable, "ReplaceMasterPage", ex.Message, ex.ToString(), "ProcessInputFile()", ex.GetType().ToString());
}
}
System.Console.ForegroundColor = System.ConsoleColor.Green;
Logger.LogSuccessMessage("[ReplaceMasterPage: DoWork] Successfully processed all sites and output file is present in the path: "
+ outputPath, true);
System.Console.ResetColor();
}
catch (Exception ex)
{
Logger.LogErrorMessage("[ReplaceMasterpage: ProcessInputFile]. Exception Message: " + ex.Message, true);
ExceptionCsv.WriteException(Constants.NotApplicable, Constants.NotApplicable, Constants.NotApplicable, "ReplaceMasterPage", ex.Message, ex.ToString(), "ProcessInputFile()", ex.GetType().ToString());
}
finally
{
dtMasterPagesInput.Dispose();
}
}
public static void GeneratePivotReports(string OutputFolderPath, string PivotConfigXMLFileName, string masterXMLrootNode, string outputPath)
{
try
{
//Formatting of Output Directory
FileUtility.ValidateDirectory(ref OutputFolderPath);
Logger.LogInfoMessage(string.Format("Pivot Report Utility Execution Started for XML: " + PivotConfigXMLFileName), true);
string PivotConfigXMLFilePath = OutputFolderPath + @"\" + PivotConfigXMLFileName;
string PivotOutputReportFullPath = String.Empty;
//XmlNodeList otherNodes = null;
List <XmlNode> otherNodes = new List <XmlNode>();
if (System.IO.File.Exists(PivotConfigXMLFilePath))
{
//Load Pivot Config Xml
XmlNodeList Components = LoadPivotConfigXML(PivotConfigXMLFilePath, masterXMLrootNode, OutputFolderPath, ref PivotOutputReportFullPath, ref otherNodes, outputPath);
if (Components != null)
{
GeneratePivotReportsUsingCSVFiles(Components, OutputFolderPath, PivotOutputReportFullPath, otherNodes);
}
}
else
{
string ErrorMessage = "[GeneratePivotReports] File Not Found Error: XML file (" + PivotConfigXMLFileName + ") is not present in path:" + PivotConfigXMLFilePath;
Logger.LogErrorMessage(ErrorMessage, true);
ExceptionCsv.WriteException(Constants.NotApplicable, Constants.NotApplicable, Constants.NotApplicable, "Pivot", ErrorMessage, Constants.NotApplicable,
"GeneratePivotReports", Constants.NotApplicable, ErrorMessage);
}
}
catch (Exception ex)
{
Logger.LogErrorMessage(string.Format("[GeneratePivotReports][Exception]: " + ex.Message), true);
ExceptionCsv.WriteException(Constants.NotApplicable, Constants.NotApplicable, Constants.NotApplicable, "Pivot", ex.Message, ex.ToString(),
"GeneratePivotReports", ex.GetType().ToString(), Constants.NotApplicable);
}
finally
{
System.Console.ForegroundColor = System.ConsoleColor.Green;
Logger.LogSuccessMessage(string.Format("Pivot Report Utility Execution Completed Successfully & Logger, Exception and Output files are saved in path: " + outputPath), true);
System.Console.ResetColor();
}
}
private static void ReportContentTypeUsage(Web web, List list, string targetContentTypeId, string targetContentTypeName)
{
try
{
list.EnsureProperty(l => l.ContentTypesEnabled);
if (!list.ContentTypesEnabled)
{
return;
}
ContentTypeCollection ctCol = list.ContentTypes;
list.Context.Load(ctCol);
list.Context.ExecuteQuery();
foreach (ContentType ct in ctCol)
{
try
{
string contentTypeId = ct.Id.StringValue;
if (contentTypeId.StartsWith(targetContentTypeId, StringComparison.InvariantCultureIgnoreCase))
{
if (ct.Name.Equals(targetContentTypeName, StringComparison.InvariantCultureIgnoreCase))
{
Logger.LogSuccessMessage(String.Format("FOUND: Content Type [{2}] on LIST [{0}] of WEB: {1}", list.Title, web.Url, targetContentTypeName), true);
}
else
{
Logger.LogSuccessMessage(String.Format("FOUND: Child Content Type [{3}] of [{2}] on LIST [{0}] of WEB: {1}", list.Title, web.Url, targetContentTypeName, ct.Name), true);
}
}
}
catch (Exception ex)
{
Logger.LogErrorMessage(String.Format("ReportContentTypeUsage() failed on a Content Type of LIST [{0}] of WEB {1}: Error={2}", list.Title, web.Url, ex.Message), false);
}
}
}
catch (Exception ex)
{
Logger.LogErrorMessage(String.Format("ReportContentTypeUsage() failed for LIST [{0}] of WEB {1}: Error={2}", list.Title, web.Url, ex.Message), false);
}
}
public static void DeleteWebPartFile(Web web, string wpFileName)
{
try
{
Logger.LogInfoMessage(String.Format("Deleting Web Part File: {0} ...", wpFileName), false);
List wpGallery = web.GetCatalog((int)ListTemplateType.WebPartCatalog);
Folder wpGalleryRoot = wpGallery.RootFolder;
web.Context.Load(wpGalleryRoot);
web.Context.ExecuteQuery();
string wpFilePath = wpGalleryRoot.ServerRelativeUrl + "/" + wpFileName;
File wpFile = web.GetFileByServerRelativeUrl(wpFilePath);
Logger.LogInfoMessage(String.Format("Deleting Web Part File: {0} ...", wpFilePath), false);
web.Context.Load(wpFile);
web.Context.ExecuteQuery();
if (wpFile.ServerObjectIsNull == false)
{
wpFile.DeleteObject();
web.Context.ExecuteQuery();
Logger.LogSuccessMessage(String.Format("Deleted Web Part File: {0}", wpFilePath), false);
}
else
{
Logger.LogErrorMessage(String.Format("DeleteWebPartFile() failed for {0}: Error=File {1} was not found", web.Url, wpFileName), false);
}
}
catch (ServerException ex)
{
if (ex.ServerErrorTypeName.Equals("System.IO.FileNotFoundException", StringComparison.InvariantCultureIgnoreCase) == false)
{
Logger.LogErrorMessage(String.Format("DeleteWebPartFile() failed for {0}: Error={1}", web.Url, ex.Message), false);
}
}
catch (Exception ex)
{
Logger.LogErrorMessage(String.Format("DeleteWebPartFile() failed for {0}: Error={1}", web.Url, ex.Message), false);
}
}
public static void DoWork()
{
string timeStamp = DateTime.Now.ToString("yyyyMMdd_hhmmss");
string NonDefMasterFileName = outputPath + @"\" + Constants.NonDefaultMasterPageFileName + timeStamp + Constants.CSVExtension;
Logger.OpenLog("GenerateNonDefaultMasterPageUsageReport", timeStamp);
if (!ShowInformation())
{
return;
}
Logger.LogInfoMessage(String.Format("Scan starting {0}", DateTime.Now.ToString()), true);
if (!System.IO.File.Exists(NonDefMasterFileName))
{
headermasterPage = false;
}
else
{
headermasterPage = true;
}
string inputFileSpec = Environment.CurrentDirectory + "\\" + Constants.UsageReport_SitesInputFileName;
if (System.IO.File.Exists(inputFileSpec))
{
string[] siteUrls = Helper.ReadInputFile(inputFileSpec, false);
Logger.LogInfoMessage(String.Format("Preparing to scan a total of {0} sites ...", siteUrls.Length), true);
foreach (string siteUrl in siteUrls)
{
ProcessSite(siteUrl, NonDefMasterFileName);
}
Logger.LogSuccessMessage(String.Format("[GenerateNonDefaultMasterPageUsageReport] Usage report is exported to the file {0}", NonDefMasterFileName), true);
}
else
{
Logger.LogErrorMessage(String.Format("[GenerateNonDefaultMasterPageUsageReport] Input file {0} is not available", inputFileSpec), true);
}
Logger.LogInfoMessage(String.Format("Scan completed {0}", DateTime.Now.ToString()), true);
Logger.CloseLog();
}
public static bool ReplaceWebPartInPage(string webUrl, string targetWebPartFileName, string targetWebPartXmlFile, string sourceWebPartStorageKey, string webPartZoneIndex, string webPartZoneID, string serverRelativePageUrl, string outPutDirectory, string sourceWebPartId = "")
{
bool isWebPartReplaced = false;
if (DeleteWebparts.DeleteWebPart(webUrl, serverRelativePageUrl, sourceWebPartStorageKey))
{
System.Console.ForegroundColor = System.ConsoleColor.Green;
Logger.LogSuccessMessage("[ReplaceWebPart]Successfully Deleted WebPart ");
System.Console.ResetColor();
if (AddWebPart.AddWebPartToPage(webUrl, targetWebPartFileName, targetWebPartXmlFile, webPartZoneIndex, webPartZoneID, serverRelativePageUrl, outPutDirectory, sourceWebPartId))
{
System.Console.ForegroundColor = System.ConsoleColor.Green;
isWebPartReplaced = true;
Logger.LogSuccessMessage("[ReplaceWebPart]Successfully Added WebPart ");
Logger.LogSuccessMessage("[ReplaceWebPart] Successfully Replaced the newly configured WebPart and output file is present in the path: " + outPutDirectory, true);
System.Console.ResetColor();
}
}
return(isWebPartReplaced);
}
private static void GenerateReportFile(List <SiteEntity> sites, string GenSiteColFileName)
{
if (!System.IO.File.Exists(GenSiteColFileName))
{
headerSiteCollection = false;
}
else
{
headerSiteCollection = true;
}
GenerateSiteCollectionnOutput objGenSiteColOutput = new GenerateSiteCollectionnOutput();
if (sites == null)
{
Logger.LogInfoMessage(String.Format("No site collections were found"), true);
return;
}
//Text File
string outputFileSpecFormat = "{0}" + DateTime.Now.ToString("yyyyMMdd_hhmmss") + ".txt";
string outputFileSpec = String.Format(outputFileSpecFormat, Constants.GenSiteCollectionFileName);
using (System.IO.StreamWriter outputFile = new System.IO.StreamWriter(outputFileSpec))
{
outputFile.AutoFlush = true;
foreach (SiteEntity site in sites)
{
//CSV File
outputFile.WriteLine(site.Url);
objGenSiteColOutput.SiteCollectionUrl = site.Url;
FileUtility.WriteCsVintoFile(GenSiteColFileName, objGenSiteColOutput, ref headerSiteCollection);
}
outputFile.Close();
Logger.LogSuccessMessage(String.Format("[GenerateSiteCollectionReport] GenerateReportFile: Usage report is exported to the file {0}", GenSiteColFileName), true);
Logger.LogMessage(String.Format("[GenerateSiteCollectionReport] GenerateReportFile: Report containing {0} sites has been saved to {1} (Text Format) and " + GenSiteColFileName + " (CSV Format) ", sites.Count, outputFileSpec), true);
}
}
/// <summary>
/// Deletes the specified file from the specified web.
/// </summary>
/// <param name="web">this MUST be the web that contains the file to delete</param>
/// <param name="serverRelativeFilePath">the SERVER-relative path to the file ("/sites/site/web/lib/folder/file.ext")</param>
public static bool DeleteFileByServerRelativeUrl(Web web, string serverRelativeFilePath)
{
bool result = false;
try
{
Logger.LogInfoMessage(String.Format("Deleting File: {0} ...", serverRelativeFilePath), false);
File targetFile = web.GetFileByServerRelativeUrl(serverRelativeFilePath);
web.Context.Load(targetFile);
web.Context.ExecuteQuery();
if (targetFile.ServerObjectIsNull == false)
{
targetFile.DeleteObject();
web.Context.ExecuteQuery();
result = true;
Logger.LogSuccessMessage(String.Format("Deleted File: {0}", serverRelativeFilePath), true);
}
else
{
Logger.LogErrorMessage(String.Format("DeleteFileByServerRelativeUrl() failed for {0}: Error={1}", serverRelativeFilePath, "File was not Found."), true);
}
}
catch (ServerException ex)
{
Logger.LogErrorMessage(String.Format("[Helper: DeleteFileByServerRelativeUrl] failed for {0}: Error={1}", serverRelativeFilePath, ex.Message), true);
ExceptionCsv.WriteException(Constants.NotApplicable, Constants.NotApplicable, web.Url, "N/A", ex.Message, ex.ToString(), "DeleteFileByServerRelativeUrl",
ex.GetType().ToString(), String.Format("DeleteFileByServerRelativeUrl() failed for {0}: Error={1}", serverRelativeFilePath, ex.Message));
}
catch (Exception ex)
{
Logger.LogErrorMessage(String.Format("[Helper: DeleteFileByServerRelativeUrl] failed for {0}: Error={1}", serverRelativeFilePath, ex.Message), true);
ExceptionCsv.WriteException(Constants.NotApplicable, Constants.NotApplicable, web.Url, "N/A", ex.Message, ex.ToString(), "DeleteFileByServerRelativeUrl",
ex.GetType().ToString(), String.Format("DeleteFileByServerRelativeUrl() failed for {0}: Error={1}", serverRelativeFilePath, ex.Message));
}
return(result);
}
private static void RemoveFeature(ClientContext userContext, Guid featureDefinitionId)
{
userContext.Load(userContext.Site);
userContext.Load(userContext.Web);
userContext.ExecuteQuery();
// The scope of the feature is unknown; search the web-scoped features first; if the feature is not found, then search the site-scoped features
if (RemoveFeatureFromWeb(userContext, featureDefinitionId))
{
Logger.LogSuccessMessage(String.Format("Deleted Feature {0} from web {1}", featureDefinitionId.ToString(), userContext.Web.Url), false);
return;
}
Logger.LogInfoMessage(String.Format("Feature was not found in the web-scoped features; trying the site-scoped features..."), false);
if (RemoveFeatureFromSite(userContext, featureDefinitionId))
{
Logger.LogSuccessMessage(String.Format("Deleted Feature {0} from site {1}", featureDefinitionId.ToString(), userContext.Site.Url), false);
return;
}
Logger.LogErrorMessage(String.Format("Could not delete Feature {0}; feature not found", featureDefinitionId.ToString()), false);
}
private static void ReportContentTypeUsage(Web web, string targetContentTypeId, string targetContentTypeName)
{
try
{
ContentTypeCollection ctCol = web.ContentTypes;
web.Context.Load(ctCol);
web.Context.ExecuteQuery();
foreach (ContentType ct in ctCol)
{
try
{
string contentTypeId = ct.Id.StringValue;
if (contentTypeId.StartsWith(targetContentTypeId, StringComparison.InvariantCultureIgnoreCase))
{
if (ct.Name.Equals(targetContentTypeName, StringComparison.InvariantCultureIgnoreCase))
{
Logger.LogSuccessMessage(String.Format("FOUND: Content Type [{1}] on WEB: {0}", web.Url, targetContentTypeName), true);
}
else
{
Logger.LogSuccessMessage(String.Format("FOUND: Child Content Type [{2}] of [{1}] on WEB: {0}", web.Url, targetContentTypeName, ct.Name), true);
}
}
}
catch (Exception ex)
{
Logger.LogErrorMessage(String.Format("ReportContentTypeUsage() failed on a Content Type of WEB {0}: Error={1}", web.Url, ex.Message), false);
}
}
}
catch (Exception ex)
{
Logger.LogErrorMessage(String.Format("ReportContentTypeUsage() failed for WEB {0}: Error={1}", web.Url, ex.Message), false);
}
}
public static string UploadMasterPage(Web web, string mpFileName, string localFilePath, string title, string description)
{
try
{
Logger.LogInfoMessage(String.Format("Uploading Master Page File: {0} ...", mpFileName), false);
List mpGallery = web.GetCatalog((int)ListTemplateType.MasterPageCatalog);
Folder mpGalleryRoot = mpGallery.RootFolder;
web.Context.Load(mpGallery);
web.Context.Load(mpGalleryRoot);
web.Context.ExecuteQuery();
string mpFilePath = mpGalleryRoot.ServerRelativeUrl + "/" + mpFileName;
File mpFile = GetFileFromWeb(web, mpFilePath);
if (mpFile == null)
{
// Get the file name from the provided path
Byte[] fileBytes = System.IO.File.ReadAllBytes(localFilePath);
// Use CSOM to upload the file in
FileCreationInformation newFile = new FileCreationInformation();
newFile.Content = fileBytes;
newFile.Overwrite = true;
newFile.Url = mpFileName;
File uploadFile = mpGalleryRoot.Files.Add(newFile);
web.Context.Load(uploadFile);
web.Context.ExecuteQuery();
}
// Grab the file we just uploaded so we can edit its properties
mpFile = GetFileFromWeb(web, mpFilePath);
if (mpGallery.ForceCheckout || mpGallery.EnableVersioning)
{
if (mpFile.CheckOutType == CheckOutType.None)
{
mpFile.CheckOut();
}
}
ListItem fileListItem = mpFile.ListItemAllFields;
fileListItem["MasterPageDescription"] = description;
fileListItem["UIVersion"] = "15";
if (mpGallery.AllowContentTypes && mpGallery.ContentTypesEnabled)
{
fileListItem["Title"] = title;
fileListItem["ContentTypeId"] = Constants.MASTERPAGE_CONTENT_TYPE;
}
fileListItem.Update();
if (mpGallery.ForceCheckout || mpGallery.EnableVersioning)
{
mpFile.CheckIn(string.Empty, CheckinType.MajorCheckIn);
if (mpGallery.EnableModeration)
{
mpFile.Approve("");
}
}
web.Context.ExecuteQuery();
Logger.LogSuccessMessage(String.Format("Uploaded Master Page File: {0}", mpFile.ServerRelativeUrl), false);
return(mpFile.ServerRelativeUrl);
}
catch (Exception ex)
{
Logger.LogErrorMessage(String.Format("UploadMasterPage() failed for {0}: Error={1}", web.Url, ex.Message), false);
return(String.Empty);
}
}
public static void UploadDisplayTemplateFileJS(Web web, string dtFileName, string localFilePath, string displayTemplateFolderName, string title, string description)
{
try
{
Logger.LogInfoMessage(String.Format("Uploading Display Template JS File: {0} ...", dtFileName), false);
List mpGallery = web.GetCatalog((int)ListTemplateType.MasterPageCatalog);
Folder mpGalleryRoot = mpGallery.RootFolder;
web.Context.Load(mpGallery);
web.Context.Load(mpGalleryRoot);
web.Context.ExecuteQuery();
string serverRelativeFolderUrl = mpGalleryRoot.ServerRelativeUrl + "/Display Templates/" + displayTemplateFolderName;
Folder dtFolder = web.GetFolderByServerRelativeUrl(serverRelativeFolderUrl);
web.Context.Load(dtFolder);
web.Context.ExecuteQuery();
string dtFilePath = dtFolder.ServerRelativeUrl + "/" + dtFileName;
File dtFile = GetFileFromWeb(web, dtFilePath);
if (dtFile == null)
{
// Get the file name from the provided path
Byte[] fileBytes = System.IO.File.ReadAllBytes(localFilePath);
// Use CSOM to upload the file in
FileCreationInformation newFile = new FileCreationInformation();
newFile.Content = fileBytes;
newFile.Overwrite = true;
newFile.Url = dtFilePath;
File uploadFile = mpGalleryRoot.Files.Add(newFile);
web.Context.Load(uploadFile);
web.Context.ExecuteQuery();
}
// Grab the file we just uploaded so we can edit its properties
dtFile = GetFileFromWeb(web, dtFilePath);
if (mpGallery.ForceCheckout || mpGallery.EnableVersioning)
{
if (dtFile.CheckOutType == CheckOutType.None)
{
dtFile.CheckOut();
}
}
ListItem fileListItem = dtFile.ListItemAllFields;
string controlContentTypeId = GetContentType(web, mpGallery, "Display Template Code");
fileListItem["Title"] = title;
fileListItem["MasterPageDescription"] = description;
fileListItem["ContentTypeId"] = controlContentTypeId;
fileListItem["TargetControlType"] = ";#Content Web Parts;#";
fileListItem["DisplayTemplateLevel"] = "Item";
fileListItem["TemplateHidden"] = "0";
fileListItem["UIVersion"] = "15";
fileListItem["ManagedPropertyMapping"] = "'Link URL'{Link URL}:'Path','Line 1'{Line 1}:'Title','Line 2'{Line 2}:'','FileExtension','SecondaryFileExtension'";
fileListItem.Update();
if (mpGallery.ForceCheckout || mpGallery.EnableVersioning)
{
dtFile.CheckIn(string.Empty, CheckinType.MajorCheckIn);
if (mpGallery.EnableModeration)
{
dtFile.Approve("");
}
}
web.Context.ExecuteQuery();
Logger.LogSuccessMessage(String.Format("Uploaded Display Template JS File: {0}", dtFile.ServerRelativeUrl), false);
}
catch (Exception ex)
{
Logger.LogErrorMessage(String.Format("UploadDisplayTemplateFileJS() failed for {0}: Error={1}", web.Url, ex.Message), false);
}
}
public static void UploadWebPartFile(Web web, string wpFileName, string localFilePath, string title, string description)
{
try
{
Logger.LogInfoMessage(String.Format("Uploading Web Part File: {0} ...", wpFileName), false);
List wpGallery = web.GetCatalog((int)ListTemplateType.WebPartCatalog);
Folder wpGalleryRoot = wpGallery.RootFolder;
web.Context.Load(wpGallery);
web.Context.Load(wpGalleryRoot);
web.Context.ExecuteQuery();
string wpFilePath = wpGalleryRoot.ServerRelativeUrl + "/" + wpFileName;
File wpFile = GetFileFromWeb(web, wpFilePath);
if (wpFile == null)
{
// Get the file name from the provided path
Byte[] fileBytes = System.IO.File.ReadAllBytes(localFilePath);
// Use CSOM to upload the file in
FileCreationInformation newFile = new FileCreationInformation();
newFile.Content = fileBytes;
newFile.Overwrite = true;
newFile.Url = wpFileName;
File uploadFile = wpGalleryRoot.Files.Add(newFile);
web.Context.Load(uploadFile);
web.Context.ExecuteQuery();
}
// Grab the file we just uploaded so we can edit its properties
wpFile = GetFileFromWeb(web, wpFilePath);
if (wpGallery.ForceCheckout || wpGallery.EnableVersioning)
{
if (wpFile.CheckOutType == CheckOutType.None)
{
wpFile.CheckOut();
}
}
ListItem fileListItem = wpFile.ListItemAllFields;
fileListItem["Title"] = title;
fileListItem["WebPartDescription"] = description;
fileListItem["Group"] = "Contoso Custom Web Parts";
fileListItem.Update();
if (wpGallery.ForceCheckout || wpGallery.EnableVersioning)
{
wpFile.CheckIn(string.Empty, CheckinType.MajorCheckIn);
if (wpGallery.EnableModeration)
{
wpFile.Approve("");
}
}
web.Context.ExecuteQuery();
Logger.LogSuccessMessage(String.Format("Uploaded Web Part File: {0}", wpFile.ServerRelativeUrl), false);
}
catch (Exception ex)
{
Logger.LogErrorMessage(String.Format("UploadWebPartFile() failed for {0}: Error={1}", web.Url, ex.Message), false);
}
}
/// <summary>
/// Executes all web-level transformations related to the custom solution.
/// Performs special processing for the root web, then recurses through all child webs.
/// </summary>
/// <param name="webUrl">Url of web to process</param>
/// <param name="isRoot">True if this is the root web</param>
private static void ProcessWeb(string webUrl, bool isRoot, string SiteURL, string NonDefMasterFileName)
{
try
{
string masterUrl = string.Empty;
string customMasterurl = string.Empty;
string WebUrl = string.Empty;
bool IsMasterUrl = false;
bool IsCustomMasterUrl = false;
NonDefaultMasterpageOutput objMasterPageOutput = new NonDefaultMasterpageOutput();
Logger.LogInfoMessage(String.Format("Scanning Web: {0} ...", webUrl), false);
using (ClientContext userContext = Helper.CreateAuthenticatedUserContext(Program.AdminDomain, Program.AdminUsername, Program.AdminPassword, webUrl))
{
Web web = userContext.Web;
userContext.Load(web);
userContext.Load(web.AllProperties);
userContext.ExecuteQuery();
if (web.MasterUrl.ToLowerInvariant().Contains("seattle.master") == false)
{
Logger.LogSuccessMessage(String.Format("FOUND: System Master Page setting (Prop=MasterUrl) of web {0} is {1}", web.Url, web.MasterUrl), true);
IsMasterUrl = true;
}
else
{
IsMasterUrl = false;
}
if (web.CustomMasterUrl.ToLowerInvariant().Contains("seattle.master") == false)
{
Logger.LogSuccessMessage(String.Format("FOUND: Site Master Page setting (Prop=CustomMasterUrl) of web {0} is {1}", web.Url, web.CustomMasterUrl), true);
IsCustomMasterUrl = true;
}
else
{
IsCustomMasterUrl = false;
}
objMasterPageOutput.MasterUrl = web.MasterUrl;
objMasterPageOutput.CustomMasterUrl = web.CustomMasterUrl;
objMasterPageOutput.WebUrl = web.Url;
objMasterPageOutput.SiteCollection = SiteURL;
if (IsMasterUrl || IsCustomMasterUrl)
{
FileUtility.WriteCsVintoFile(NonDefMasterFileName, objMasterPageOutput, ref headermasterPage);
}
// Process all child webs
web.Context.Load(web.Webs);
web.Context.ExecuteQuery();
foreach (Web childWeb in web.Webs)
{
if (childWeb.Url.ToLower().Contains(SiteURL.ToLower()))
{
ProcessWeb(childWeb.Url, false, SiteURL, NonDefMasterFileName);
}
}
}
}
catch (Exception ex)
{
Logger.LogErrorMessage(String.Format("[GenerateNonDefaultMasterPageUsageReport] ProcessWeb() failed for {0}: Error={1}", webUrl, ex.Message), false);
ExceptionCsv.WriteException(Constants.NotApplicable, Constants.NotApplicable, webUrl, "NonDefaultMastePageUsageReport", ex.Message, ex.ToString(), "ProcessWeb()", ex.GetType().ToString(), String.Format("ProcessWeb() failed for {0}: Error={1}", webUrl, ex.Message));
}
}
