Esempio n. 1
0
        public override TokenParser ProvisionObjects(Web web, ProvisioningTemplate template, TokenParser parser, ProvisioningTemplateApplyingInformation applyingInformation)
        {
            using (var scope = new PnPMonitoredScope(this.Name))
            {
                // Check if this is not a noscript site as we're not allowed to write to the web property bag is that one
                bool isNoScriptSite = web.IsNoScriptSite();

                var context = web.Context as ClientContext;

                web.EnsureProperties(w => w.ServerRelativeUrl, w => w.Url);

                // Build on the fly the list of additional files coming from the Directories
                var directoryFiles = new List <Model.File>();
                foreach (var directory in template.Directories)
                {
                    var metadataProperties = directory.GetMetadataProperties();
                    directoryFiles.AddRange(directory.GetDirectoryFiles(metadataProperties));
                }

                foreach (var file in template.Files.Union(directoryFiles))
                {
                    var folderName = parser.ParseString(file.Folder);

                    if (folderName.ToLower().StartsWith((web.ServerRelativeUrl.ToLower())))
                    {
                        folderName = folderName.Substring(web.ServerRelativeUrl.Length);
                    }

                    if (SkipFile(isNoScriptSite, file.Src, folderName))
                    {
                        // add log message
                        scope.LogWarning(CoreResources.Provisioning_ObjectHandlers_Files_SkipFileUpload, file.Src, folderName);
                        continue;
                    }

                    var folder = web.EnsureFolderPath(folderName);

                    File targetFile = null;

                    var checkedOut = false;

                    targetFile = folder.GetFile(template.Connector.GetFilenamePart(file.Src));

                    if (targetFile != null)
                    {
                        if (file.Overwrite)
                        {
                            scope.LogDebug(CoreResources.Provisioning_ObjectHandlers_Files_Uploading_and_overwriting_existing_file__0_, file.Src);
                            checkedOut = CheckOutIfNeeded(web, targetFile);

                            using (var stream = GetFileStream(template, file))
                            {
                                targetFile = UploadFile(template, file, folder, stream);
                            }
                        }
                        else
                        {
                            checkedOut = CheckOutIfNeeded(web, targetFile);
                        }
                    }
                    else
                    {
                        using (var stream = GetFileStream(template, file))
                        {
                            scope.LogDebug(CoreResources.Provisioning_ObjectHandlers_Files_Uploading_file__0_, file.Src);
                            targetFile = UploadFile(template, file, folder, stream);
                        }

                        checkedOut = CheckOutIfNeeded(web, targetFile);
                    }

                    if (targetFile != null)
                    {
                        if (file.Properties != null && file.Properties.Any())
                        {
                            Dictionary <string, string> transformedProperties = file.Properties.ToDictionary(property => property.Key, property => parser.ParseString(property.Value));
                            SetFileProperties(targetFile, transformedProperties, false);
                        }

                        if (file.WebParts != null && file.WebParts.Any())
                        {
                            targetFile.EnsureProperties(f => f.ServerRelativeUrl);

                            var existingWebParts = web.GetWebParts(targetFile.ServerRelativeUrl);
                            foreach (var webpart in file.WebParts)
                            {
                                // check if the webpart is already set on the page
                                if (existingWebParts.FirstOrDefault(w => w.WebPart.Title == webpart.Title) == null)
                                {
                                    scope.LogDebug(CoreResources.Provisioning_ObjectHandlers_Files_Adding_webpart___0___to_page, webpart.Title);
                                    var 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(targetFile.ServerRelativeUrl, wpEntity);
                                }
                            }
                        }

                        switch (file.Level)
                        {
                        case Model.FileLevel.Published:
                        {
                            targetFile.PublishFileToLevel(Microsoft.SharePoint.Client.FileLevel.Published);
                            break;
                        }

                        case Model.FileLevel.Draft:
                        {
                            targetFile.PublishFileToLevel(Microsoft.SharePoint.Client.FileLevel.Draft);
                            break;
                        }

                        default:
                        {
                            if (checkedOut)
                            {
                                targetFile.CheckIn("", CheckinType.MajorCheckIn);
                                web.Context.ExecuteQueryRetry();
                            }
                            break;
                        }
                        }

                        // Don't set security when nothing is defined. This otherwise breaks on files set outside of a list
                        if (file.Security != null &&
                            (file.Security.ClearSubscopes == true || file.Security.CopyRoleAssignments == true || file.Security.RoleAssignments.Count > 0))
                        {
                            targetFile.ListItemAllFields.SetSecurity(parser, file.Security);
                        }
                    }
                }
            }
            return(parser);
        }
Esempio n. 2
0
        private static void CommentUDCXFileNode(UdcxReportInput udcxFileInput, List <UdcxReportOutput> _WriteUDCList)
        {
            if (udcxFileInput == null)
            {
                return;
            }

            string siteUrl        = udcxFileInput.SiteUrl;
            string webUrl         = udcxFileInput.WebUrl;
            string dirName        = udcxFileInput.DirName;
            string leafName       = udcxFileInput.LeafName;
            string authentication = udcxFileInput.Authentication;

            UdcxReportOutput udcxOutput = new UdcxReportOutput();

            udcxOutput.SiteUrl        = siteUrl;
            udcxOutput.WebUrl         = webUrl;
            udcxOutput.DirName        = dirName;
            udcxOutput.LeafName       = leafName;
            udcxOutput.Authentication = authentication;

            if (dirName.EndsWith("/"))
            {
                dirName = dirName.TrimEnd(new char[] { '/' });
            }
            if (leafName.StartsWith("/"))
            {
                leafName = leafName.TrimStart(new char[] { '/' });
            }
            string serverRelativeFolderPath = "/" + dirName;
            string serverRelativeFilePath   = "/" + dirName + '/' + leafName;

            try
            {
                Logger.LogInfoMessage(String.Format("Processing UCDX File [{0}/{1}] of Web [{2}] ...", dirName, leafName, webUrl), true);

                // IMPORTANT: Open the webUrl, not the siteUrl, so Folder.Files.Add() can properly process files of child webs
                using (ClientContext userContext = Helper.CreateClientContextBasedOnAuthMode(Program.UseAppModel, Program.AdminDomain, Program.AdminUsername, Program.AdminPassword, webUrl))
                {
                    Web web = userContext.Web;
                    userContext.Load(web);
                    userContext.ExecuteQuery();

                    XNamespace xns = "http://schemas.microsoft.com/office/infopath/2006/udc";
                    XDocument  doc = null;

                    Logger.LogInfoMessage(String.Format("Getting contents of UCDX File [{0}] from Web [{1}] ...", serverRelativeFilePath, webUrl), false);
                    // Approach to read File contents depends on Auth Model chosen
                    if (Program.UseAppModel == true)
                    {
                        string originalFileContents = SafeGetFileAsString(web, serverRelativeFilePath);
                        if (String.IsNullOrEmpty(originalFileContents))
                        {
                            Logger.LogErrorMessage(String.Format("Could not get contents of UCDX File"), false);
                            udcxOutput.Status = Constants.ErrorStatus + ": could not get file contents.";
                            _WriteUDCList.Add(udcxOutput);
                            return;
                        }

                        doc = XDocument.Load(new StringReader(originalFileContents));
                    }
                    else
                    {
                        FileInformation info = Microsoft.SharePoint.Client.File.OpenBinaryDirect(userContext, serverRelativeFilePath);
                        doc = XDocument.Load(XmlReader.Create(info.Stream));
                    }
                    Logger.LogInfoMessage(String.Format("Got contents of UCDX File"), false);

                    XElement authElem = doc.Root.Element(xns + "ConnectionInfo").Element(xns + "Authentication");
                    if (authElem != null)
                    {
                        string authData = authElem.ToString();
                        authData = authData.Replace("<udc:Authentication xmlns:udc=\"" + xns + "\">", "<udc:Authentication>");
                        authElem.ReplaceWith(new XComment(authData));

                        string saveUdcxContent = doc.Declaration.ToString() + doc.ToString();

                        using (MemoryStream contentStream = new MemoryStream())
                        {
                            StreamWriter writer = new StreamWriter(contentStream);
                            writer.Write(saveUdcxContent);
                            writer.Flush();
                            contentStream.Position = 0;

                            Logger.LogInfoMessage(String.Format("Saving contents of UCDX File [{0}] to Web [{1}] ...", serverRelativeFilePath, webUrl), false);
                            // Approach to save File contents depends on Auth Model chosen
                            if (Program.UseAppModel == true)
                            {
                                Folder targetFolder = null;

                                // grab the parent folder in preparation for the file upload...
                                Logger.LogInfoMessage(String.Format("Getting folder [{0}] of Web [{1}] ...", serverRelativeFolderPath, webUrl), false);
                                try
                                {
                                    targetFolder = web.GetFolderByServerRelativeUrl(serverRelativeFolderPath);
                                    userContext.Load(targetFolder);
                                    userContext.ExecuteQuery();

                                    Logger.LogInfoMessage(String.Format("Got folder"), false);
                                }
                                catch (Exception ex)
                                {
                                    Logger.LogErrorMessage(String.Format("CommentUDCXFileNode() failed for UDCX File [{0}/{1}] of Web [{2}]: Reason={3}; Error={4}", dirName, leafName, webUrl,
                                                                         "Upload Folder was not Found.",
                                                                         "[" + ex.Message + "] | [" + ex.HResult + "] | [" + ex.Source + "] | [" + ex.StackTrace + "] | [" + ex.TargetSite + "]"), false);
                                    udcxOutput.Status = Constants.ErrorStatus + ": Upload Folder was not Found.";
                                    _WriteUDCList.Add(udcxOutput);
                                    return;
                                }

                                // check-out the file (if needed) in preparation for the file upload...
                                try
                                {
                                    Logger.LogInfoMessage(String.Format("Checking out file [{0}] ...", leafName), false);
                                    web.CheckOutFile(serverRelativeFilePath);
                                    Logger.LogInfoMessage(String.Format("Checked out file"), false);
                                }
                                catch (Exception ex)
                                {
                                    Logger.LogErrorMessage(String.Format("CommentUDCXFileNode() failed for UDCX File [{0}/{1}] of Web [{2}]: Reason={3}; Error={4}", dirName, leafName, webUrl,
                                                                         "File Checkout failed.",
                                                                         "[" + ex.Message + "] | [" + ex.HResult + "] | [" + ex.Source + "] | [" + ex.StackTrace + "] | [" + ex.TargetSite + "]"), false);
                                    udcxOutput.Status = Constants.ErrorStatus + ": File Checkout failed.";
                                    _WriteUDCList.Add(udcxOutput);
                                    return;
                                }

                                // upload the modified file...
                                Microsoft.SharePoint.Client.File targetFile = null;
                                Logger.LogInfoMessage(String.Format("Uploading file [{0}] ...", leafName), false);
                                try
                                {
                                    targetFile = targetFolder.UploadFile(leafName, contentStream, true);
                                    Logger.LogInfoMessage(String.Format("Uploaded file"), false);
                                }
                                catch (Exception ex)
                                {
                                    Logger.LogErrorMessage(String.Format("CommentUDCXFileNode() failed for UDCX File [{0}/{1}] of Web [{2}]: Reason={3}; Error={4}", dirName, leafName, webUrl,
                                                                         "File Upload failed.",
                                                                         "[" + ex.Message + "] | [" + ex.HResult + "] | [" + ex.Source + "] | [" + ex.StackTrace + "] | [" + ex.TargetSite + "]"), false);
                                    udcxOutput.Status = Constants.ErrorStatus + ": File Upload failed.";
                                    _WriteUDCList.Add(udcxOutput);
                                    return;
                                }

                                // publish the modified file (executes check-in, publish, and approval as needed)...
                                try
                                {
                                    Logger.LogInfoMessage(String.Format("Publishing file [{0}] ...", leafName), false);
                                    targetFile.PublishFileToLevel(FileLevel.Published);
                                    Logger.LogInfoMessage(String.Format("Published file"), false);
                                }
                                catch (Exception ex)
                                {
                                    Logger.LogErrorMessage(String.Format("CommentUDCXFileNode() failed for UDCX File [{0}/{1}] of Web [{2}]: Reason={3}; Error={4}", dirName, leafName, webUrl,
                                                                         "File Publish failed.",
                                                                         "[" + ex.Message + "] | [" + ex.HResult + "] | [" + ex.Source + "] | [" + ex.StackTrace + "] | [" + ex.TargetSite + "]"), false);
                                    udcxOutput.Status = Constants.ErrorStatus + ": File Publish failed.";
                                    _WriteUDCList.Add(udcxOutput);
                                    return;
                                }
                            }
                            else
                            {
                                Microsoft.SharePoint.Client.File.SaveBinaryDirect(userContext, serverRelativeFilePath, contentStream, true);
                            }
                            Logger.LogInfoMessage(String.Format("Saved contents of UCDX File [{0}] to Web [{1}]", serverRelativeFilePath, webUrl), false);

                            udcxOutput.Status = Constants.SuccessStatus;
                            Logger.LogSuccessMessage(String.Format("Updated UCDX File [{0}/{1}] of Web [{2}]", dirName, leafName, webUrl), false);
                        }
                    }
                    else
                    {
                        udcxOutput.Status = Constants.NoAuthNodeFound;
                        Logger.LogWarningMessage(String.Format("Skipped UCDX File [{0}/{1}] of Web [{2}]: Reason={3}", dirName, leafName, webUrl, Constants.NoAuthNodeFound), false);
                    }
                }
            }
            catch (Exception ex)
            {
                Logger.LogErrorMessage(String.Format("CommentUDCXFileNode() failed for UDCX File [{0}/{1}] of Web [{2}]: Error={3}", dirName, leafName, webUrl, ex.Message), false);
                udcxOutput.Status       = Constants.ErrorStatus;
                udcxOutput.ErrorDetails = ex.Message;
            }

            _WriteUDCList.Add(udcxOutput);
        }