CSOM : How to remove permission of all the SharePoint users?

public static void RemoveSitePermissions(string strURL)
        {
            AuthenticationManager authManagerSource = new AuthenticationManager();
            using (ClientContext clientContextSource = authManagerSource.GetWebLoginClientContext(strURL))
            {
                clientContextSource.RequestTimeout = 9999999;
                Web sourceWeb = clientContextSource.Web;
                clientContextSource.Load(sourceWeb, w => w.HasUniqueRoleAssignments, w => w.RoleDefinitions, w => w.ServerRelativeUrl, w => w.Title);
                clientContextSource.ExecuteQuery();


                if (sourceWeb.HasUniqueRoleAssignments)
                {
                    RoleAssignmentCollection webRoleAssignments = sourceWeb.RoleAssignments;
                    clientContextSource.Load(webRoleAssignments);
                    clientContextSource.ExecuteQuery();
                    Console.WriteLine("Removing permissions from web..\r\n\r\n");
                    foreach (RoleAssignment webRoleAssignment in webRoleAssignments)
                    {
                        clientContextSource.Load(webRoleAssignment, r => r.Member, r => r.RoleDefinitionBindings);
                        clientContextSource.ExecuteQuery();
                        Principal oPrincipal = webRoleAssignment.Member;
                        if (oPrincipal.PrincipalType == PrincipalType.User)
                        {

                            foreach (RoleDefinition rd in webRoleAssignment.RoleDefinitionBindings)
                            {
                                try
                                {
                                    if (rd.Name != "Limited Access")
                                    {
                                        clientContextSource.Load(rd);
                                        webRoleAssignment.RoleDefinitionBindings.Remove(rd);
                                        webRoleAssignment.Update();
                                        clientContextSource.Load(webRoleAssignment, r => r.Member, r => r.RoleDefinitionBindings);
                                        sourceWeb.Update();
                                        clientContextSource.ExecuteQuery();
                                        Console.Write(".");
                                    }
                                }
                                catch (Exception ex)
                                { }
                            }
                        }
                    }
                }
                ListCollection listColl = sourceWeb.Lists;
                clientContextSource.Load(listColl, lc => lc.Include(l => l.HasUniqueRoleAssignments, l => l.Hidden, l => l.Title));
                clientContextSource.ExecuteQuery();

                foreach (List list in listColl)
                {
                    if (list.HasUniqueRoleAssignments && (!list.Hidden))
                    {

                        RoleAssignmentCollection oRoleAssignments = list.RoleAssignments;
                        clientContextSource.Load(oRoleAssignments);
                        clientContextSource.ExecuteQuery();

                        Console.WriteLine("Removing permissions from lists..\r\n\r\n");
                        foreach (RoleAssignment listRoleAssignment in oRoleAssignments)
                        {
                            clientContextSource.Load(listRoleAssignment, r => r.Member, r => r.RoleDefinitionBindings);
                            clientContextSource.ExecuteQuery();
                            Principal oPrincipal = listRoleAssignment.Member;
                            if (oPrincipal.PrincipalType == PrincipalType.User)
                            {
                                foreach (RoleDefinition rd in listRoleAssignment.RoleDefinitionBindings)
                                {
                                    try
                                    {
                                        if (rd.Name != "Limited Access")
                                        {
                                            clientContextSource.Load(rd);
                                            listRoleAssignment.RoleDefinitionBindings.Remove(rd);
                                            listRoleAssignment.Update();
                                            clientContextSource.Load(listRoleAssignment, r => r.Member, r => r.RoleDefinitionBindings);
                                            list.Update();
                                            clientContextSource.ExecuteQuery();
                                            Console.Write(".");
                                        }
                                    }
                                    catch { }
                                }
                            }
                        }


                    }
                }
            }
        }

Reference: https://sharepoint.stackexchange.com/a/228169

SSOM: How to copy SharePoint permissions from one user account to another?

protected static void CopySitePermissions_Source_Groups(string strUrl)
        {
            try
            {
                Console.WriteLine("\n\rStarting new site at: " + DateTime.Now + "\n\r");
                LogStartingNewSite(strUrl);
            }
            catch (Exception ex)
            {
                string strmsg = ex.Message;
            }
            using (SPSite site = new SPSite(strUrl))
            {
                using (SPWeb Web = site.OpenWeb())
                {
                    foreach (SPGroup siteGroup in Web.Groups)
                    {
                        foreach (SPUser objUser in siteGroup.Users)
                        {
                            try
                            {
                                string TargetUserID = SourceUserID + "@company.com";

                                if (Web.HasUniqueRoleAssignments)
                                {
                                    CopyUserPermissions(SourceUserID, TargetUserID, Web, Web);
                                }

                                foreach (SPList List in Web.Lists)
                                {
                                    if (List.HasUniqueRoleAssignments && (!List.Hidden))
                                    {
                                        CopyUserPermissions(SourceUserID, TargetUserID, Web, List);
                                    }

                                    if (List.Folders != null)
                                    {
                                        foreach (SPListItem folder in List.Folders)
                                        {
                                            if (folder.HasUniqueRoleAssignments)
                                            {
                                                CopyUserPermissions(SourceUserID, TargetUserID, Web, folder);
                                            }
                                        }
                                    }

                                    foreach (SPListItem item in List.Items)
                                    {
                                        if (item.HasUniqueRoleAssignments)
                                        {
                                            CopyUserPermissions(SourceUserID, TargetUserID, Web, item);
                                        }
                                    }
                                }

                            }
                            catch (Exception ex)
                            {
                                string strEx = ex.Message;
                            }
                        }
                    }

                    foreach (SPUser objUser in Web.Users)
                    {
                        try
                        {
                         
                            string TargetUserID = SourceUserID + "@company.com";

                            if (Web.HasUniqueRoleAssignments)
                            {
                                CopyUserPermissions(SourceUserID, TargetUserID, Web, Web);
                            }

                            foreach (SPList List in Web.Lists)
                            {
                                if (List.HasUniqueRoleAssignments && (!List.Hidden))
                                {
                                    CopyUserPermissions(SourceUserID, TargetUserID, Web, List);
                                }

                                if (List.Folders != null)
                                    {
                                        foreach (SPListItem folder in List.Folders)
                                        {
                                            if (folder.HasUniqueRoleAssignments)
                                            {
                                                CopyUserPermissions(SourceUserID, TargetUserID, Web, folder);
                                            }
                                        }
                                    }

                                    foreach (SPListItem item in List.Items)
                                    {
                                        if (item.HasUniqueRoleAssignments)
                                        {
                                            CopyUserPermissions(SourceUserID, TargetUserID, Web, item);
                                        }
                                    }
                            }
                        }
                        catch (Exception ex)
                        {
                            //log error
                        }
                    }

                }
            }
        }


public static void CopyUserPermissions(string SourceUserID, string TargetUserID, SPWeb web, SPSecurableObject Object)
        {
            try
            {
                var SourceUser = web.EnsureUser(SourceUserID);
                var TargetUser = web.EnsureUser(TargetUserID);

                var SourcePermissions = Object.GetUserEffectivePermissionInfo(SourceUser.LoginName);

                foreach (var SourceRoleAssignment in SourcePermissions.RoleAssignments)
                {
                    List<string> SourceUserPermissions = new List<string>();
                    foreach (SPRoleDefinition SourceRoleDefinition in SourceRoleAssignment.RoleDefinitionBindings)
                    {
                        if (SourceRoleDefinition.Name != "Limited Access")
                        {
                            SourceUserPermissions.Add(SourceRoleDefinition.Name);
                        }
                    }

                    if (SourceUserPermissions.Count > 0)
                    {
                        if (SourceRoleAssignment.Member is SPGroup)
                        {
                            var Group = (SPGroup)SourceRoleAssignment.Member;
                            var flag = false;
                            foreach (SPUser user in Group.Users)
                            {
                                if (user.LoginName == TargetUserID)
                                {
                                    flag = true;
                                }
                            }
                            if (!flag)
                            {
                                Group.AddUser(TargetUser);
                                try
                                {
                                    LogOperation(web.ServerRelativeUrl, SourceUserID.Split('|')[2], "Group", Group.Name);
                                    Console.WriteLine("Added " + SourceUserID.Split('|')[2] + " in Group: " + Group.Name + " at " + web.ServerRelativeUrl);
                                }
                                catch (Exception ex)
                                {
                                     //log error
                                }
                            }
                        }
                        else
                        {
                            foreach (string NewRoleDefinition in SourceUserPermissions)
                            {
                                var NewRoleAssignment = new SPRoleAssignment(TargetUser);
                                NewRoleAssignment.RoleDefinitionBindings.Add(web.RoleDefinitions[NewRoleDefinition]);

                                if (Object.GetType().Equals(typeof(SPWeb)))
                                {
                                    SPWeb spWeb = Object as SPWeb;
                                    spWeb.RoleAssignments.Add(NewRoleAssignment);
                                    spWeb.Update();
                                    try
                                    {
                                        LogOperation(web.ServerRelativeUrl, SourceUserID.Split('|')[2], "Site", spWeb.Title);
                                        Console.WriteLine("Added " + SourceUserID.Split('|')[2]+ " in Site: " + spWeb.Title + " at " + web.ServerRelativeUrl);
                                    }
                                    catch (Exception ex)
                                    {
                                         //log error
                                    }
                                }
                                if (Object.GetType().Equals(typeof(SPList)))
                                {
                                    SPList list = Object as SPList;
                                    list.RoleAssignments.Add(NewRoleAssignment);
                                    list.Update();
                                    try
                                    {
                                        LogOperation(web.ServerRelativeUrl, SourceUserID.Split('|')[2], "List", list.Title);
                                        Console.WriteLine("Added " + SourceUserID.Split('|')[2] + " in List: " + list.Title + " at " + web.ServerRelativeUrl);
                                    }
                                    catch (Exception ex)
                                    {
                                        string strmsg = ex.Message;
                                    }
                                }
                                if (Object.GetType().Equals(typeof(SPListItem)))
                                {
                                    SPListItem item = Object as SPListItem;
                                    item.RoleAssignments.Add(NewRoleAssignment);
                                    item.Update();
                                    try
                                    {
                                        LogOperation(web.ServerRelativeUrl, SourceUserID.Split('|')[2], "Item", item.ID.ToString());
                                        Console.WriteLine("Added " + SourceUserID.Split('|')[2]+ " in Item: " + item.ID.ToString() + " at " + web.ServerRelativeUrl);
                                    }
                                    catch (Exception ex)
                                    {
                                        //log error
                                    }
                                }

                            }
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                try
                {
                    LogError(ex.Message, SourceUserID.Split('|')[1], web.ServerRelativeUrl);
                    Console.WriteLine("\n\rERROR at " + web.ServerRelativeUrl + " while adding " + SourceUserID.Split('|')[1] +
                        " Message: " + ex.Message + "\n\r");
                }
                catch { }
            }
        }

Reference: https://www.sharepointdiary.com/2015/01/clone-sharepoint-user-permissions-using-powershell.html

CSOM: How to copy all files from one SharePoint library to another?

private void btnCopyFiles_Click(object sender, EventArgs e)
        {
            int itemProcessed = 0;
            try
            {
                F.MessageBox.Show("Please make sure the workflows are disabled on the target list.");
                progressBar1.Value = 0;


                PnP.AuthenticationManager authManagerTarget = new PnP.AuthenticationManager();
                using (ClientContext clientContextTarget = authManagerTarget.GetWebLoginClientContext(txtTargetSite.Text))
                {
                    clientContextTarget.RequestTimeout = 9999999;
                    List targetList = clientContextTarget.Web.Lists.GetByTitle(drpTargetList.SelectedItem.ToString());
                    clientContextTarget.Load(targetList);
                    clientContextTarget.ExecuteQueryRetry();

                    PnP.AuthenticationManager authManagerSource = new PnP.AuthenticationManager();
                    using (ClientContext clientContextSource = authManagerSource.GetWebLoginClientContext(txtSourceSite.Text))
                    {
                        List sourceList = clientContextSource.Web.Lists.GetByTitle(drpSourceList.SelectedItem.ToString());
                        CamlQuery camlQuery = new CamlQuery();
                        camlQuery.ViewXml = "<View Scope ='RecursiveAll'></View>";
                        ListItemCollection sourceItems = sourceList.GetItems(camlQuery);
                        clientContextSource.Load(sourceItems);
                        clientContextSource.ExecuteQueryRetry();

                        progressBar1.Maximum = sourceItems.Count;


                        int itemToSkip = 0;
                        try
                        {
                            itemToSkip = txtItemsToSkip.Text.ToInt32();
                        }
                        catch { }

                        string sourceLibrary = string.Empty;
                        string targetLibrary = drpTargetList.SelectedItem.ToString();
                        string fileName = string.Empty;
                        string fileUrl = string.Empty;
                        string folderPath = string.Empty;
                        Web targetWeb = clientContextTarget.Web;
                        clientContextTarget.Load(targetWeb, u => u.ServerRelativeUrl);
                        clientContextTarget.ExecuteQueryRetry();
                        string _path = targetWeb.ServerRelativeUrl;

                        try
                        {
                            sourceLibrary = sourceItems[0].FieldValues["FileDirRef"].ToString();
                            string[] urlArr = sourceLibrary.Split('/');
                            sourceLibrary = urlArr[urlArr.Count() - 1];
                        }
                        catch { }

                        foreach (ListItem sourceItem in sourceItems)
                        {
                            itemProcessed++;

                            if (itemProcessed <= txtItemsToSkip.Text.ToInt32())
                            {
                                progressBar1.Value += 1;
                                continue;
                            }

                            if (sourceItem.FileSystemObjectType == FileSystemObjectType.File)
                            {
                                try
                                {
                                    fileUrl = sourceItem["FileRef"].ToString();
                                    if (!FileExists(targetList, fileUrl.Replace("/Shared Documents/","/Documents/")))
                                    {
                                        string[] fileNames = fileUrl.Split(new string[] { sourceLibrary }, StringSplitOptions.None);
                                        fileName = fileNames[fileNames.Count() - 1];

                                        MSC.File file = sourceItem.File;
                                        clientContextSource.Load(file);
                                        clientContextSource.ExecuteQueryRetry();

                                        FileInformation fileInfo = MSC.File.OpenBinaryDirect(clientContextSource, file.ServerRelativeUrl);
                                        MSC.File.SaveBinaryDirect(clientContextTarget, _path + "/" + targetLibrary + fileName, fileInfo.Stream, false);
                                    }
                                }
                                catch (Exception ex)
                                {
                                    this.LogCopyError(ex, "File", targetLibrary, fileUrl);
                                }
                            }

                            else if (sourceItem.FileSystemObjectType == FileSystemObjectType.Folder)
                            {
                                try
                                {
                                    folderPath = sourceItem["FileRef"].ToString();
                                    string[] fileNames = folderPath.Split(new string[] { sourceLibrary }, StringSplitOptions.None);
                                    folderPath = fileNames[fileNames.Count() - 1];
                                    folderPath = folderPath.TrimStart(new Char[] { '/' });
                                    MSC.Folder folder = CreateFolder(clientContextTarget.Web, drpTargetList.SelectedItem.ToString(), folderPath);
                                }
                                catch (Exception ex)
                                {
                                    this.LogError(ex);
                                }
                            }

                            progressBar1.Value += 1;
                        }
                    }
                }
                F.MessageBox.Show("Done. Please match the items count");
            }
            catch (Exception ex)
            {
                this.LogError(ex);
                F.MessageBox.Show("Something went wrong. Please check the logs.");
                try
                {
                    F.MessageBox.Show("Items processed: " + (--itemProcessed));
                }
                catch { }
            }
        }

        private MSC.Folder CreateFolder(Web web, string listTitle, string fullFolderPath)
        {

            if (string.IsNullOrEmpty(fullFolderPath))
                throw new ArgumentNullException("fullFolderPath");
            var list = web.Lists.GetByTitle(listTitle);
            return CreateFolderInternal(web, list.RootFolder, fullFolderPath);

        }

        private MSC.Folder CreateFolderInternal(Web web, MSC.Folder parentFolder, string fullFolderPath)
        {

            var folderUrls = fullFolderPath.Split(new char[] { '/' }, StringSplitOptions.RemoveEmptyEntries);
            string folderUrl = folderUrls[0];
            var curFolder = parentFolder.Folders.Add(folderUrl);
            web.Context.Load(curFolder);
            web.Context.ExecuteQueryRetry();

            if (folderUrls.Length > 1)
            {
                var folderPath = string.Join("/", folderUrls, 1, folderUrls.Length - 1);
                return CreateFolderInternal(web, curFolder, folderPath);
            }

            return curFolder;
        }

        public bool FileExists(List list, string fileUrl)
        {
            var ctx = list.Context;
            var qry = new CamlQuery();
            qry.ViewXml = string.Format("<View Scope=\"RecursiveAll\"><Query><Where><Eq><FieldRef Name=\"FileRef\"/><Value Type=\"Url\">{0}</Value></Eq></Where></Query></View>", fileUrl);
            var items = list.GetItems(qry);
            ctx.Load(items);
            ctx.ExecuteQuery();
            return items.Count > 0;
        }

Reference: https://sharepoint.stackexchange.com/a/203283

CSOM: How to copy all items from one SharePoint list to another?

using F = System.Windows.Forms;
using Microsoft.SharePoint.Client;
using PnP = OfficeDevPnP.Core;

PnP.AuthenticationManager authManagerTarget = new PnP.AuthenticationManager();
                using (ClientContext clientContextTarget = authManagerTarget.GetWebLoginClientContext(txtTargetSite.Text))
                {
                    List targetList = clientContextTarget.Web.Lists.GetByTitle(drpTargetList.SelectedItem.ToString());
                    clientContextTarget.Load(targetList);
                    clientContextTarget.ExecuteQuery();

                    PnP.AuthenticationManager authManagerSource = new PnP.AuthenticationManager();
                    using (ClientContext clientContextSource = authManagerSource.GetWebLoginClientContext(txtSourceSite.Text))
                    {
                        List sourceList = clientContextSource.Web.Lists.GetByTitle(drpSourceList.SelectedItem.ToString());
                        ListItemCollection sourceItems = sourceList.GetItems(CamlQuery.CreateAllItemsQuery());
                        clientContextSource.Load(sourceItems);
                        clientContextSource.ExecuteQuery();

                        progressBar1.Maximum = sourceItems.Count;

                        foreach (ListItem sourceItem in sourceItems)
                        {
                            ListItemCreationInformation newItem = new ListItemCreationInformation();
                            ListItem targetItem = targetList.AddItem(newItem);
                            FieldCollection sourceFields = sourceList.Fields;
                            clientContextSource.Load(sourceFields);
                            clientContextSource.ExecuteQuery();
                            foreach (Field field in sourceFields)
                            {
                                if (field.InternalName != "Attachments" && field.InternalName != "ContentType" &&
                                     !field.Hidden && !field.ReadOnlyField &&
                                     sourceItem[field.InternalName] != null &&
field.FieldTypeKind.ToString() != "URL" && field.FieldTypeKind.ToString() != "WorkflowStatus")
                                {
                                    try
                                    {
                                        targetItem[field.InternalName] = sourceItem[field.InternalName];
                                    }
                                    catch (Exception ex)
                                    {
                                        this.LogError(ex);
                                    }
                                }
                            }
                            targetItem.Update();
                            clientContextTarget.ExecuteQueryRetryAsync(10, 10000);
                            progressBar1.Value += 1;
                        }
                    }
                }

CSOM: How to delete all items in a SharePoint list?

using F = System.Windows.Forms;
using Microsoft.SharePoint.Client;
using PnP = OfficeDevPnP.Core;

try
            {
                PnP.AuthenticationManager authManager = new PnP.AuthenticationManager();
                using (ClientContext clientContext = authManager.GetWebLoginClientContext(txtSourceUrl.Text))
                {
                    List list = clientContext.Web.Lists.GetByTitle(drpLists.SelectedItem.ToString());
                    CamlQuery camlQuery = new CamlQuery();
                    camlQuery.ViewXml = "<View><Query><Where><Neq><FieldRef Name='ID' /><Value Type='Counter'>0</Value></Neq></Where></Query></View>";
                    ListItemCollection allItems = list.GetItems(camlQuery);
                    clientContext.Load(allItems);
                    clientContext.ExecuteQuery();
                    int itemCount = allItems.Count;
                    F.MessageBox.Show("Deletion is started. Please monitor the count on SharePoint.");
                    if (itemCount > 0)
                    {
                        for (int i = itemCount - 1; i > -1; i--)
                        {
                            allItems[i].DeleteObject();
                            clientContext.ExecuteQuery();
                        }
                    }
                    F.MessageBox.Show("Items are deleted.");
                }
            }
            catch (Exception ex)
            {
                F.MessageBox.Show("Error: " + ex.Message);
            }
        }

CSOM: How to compare fields of two SharePoint lists?

using F = System.Windows.Forms;
using Microsoft.SharePoint.Client;
using PnP = OfficeDevPnP.Core;

private void btnCompare_Click(object sender, EventArgs e)
        {
            try
            {
                //Get source fields
                PnP.AuthenticationManager authManagerSource = new PnP.AuthenticationManager();
                ClientContext clientContextSource = authManagerSource.GetWebLoginClientContext(txtSourceList.Text);

                List sourceList = clientContextSource.Web.Lists.GetByTitle(drpSourceLists.SelectedItem.ToString());
                // fetch the fields from this list
                FieldCollection sourceFields = sourceList.Fields;
                clientContextSource.Load(sourceFields);
                clientContextSource.ExecuteQuery();

                var sourceColumns = new List<KeyValuePair<string, string>>();
                sourceColumns.Add(new KeyValuePair<string, string>("ID", "ID"));

                foreach (var f in sourceFields)
                {
                    if (f.InternalName.StartsWith("_") || f.InternalName.StartsWith("ows"))
                    {
                        continue;  // note: this will also skip the user created fields
                    }
                        sourceColumns.Add(new KeyValuePair<string, string>(f.InternalName, f.Title + "|" + f.FieldTypeKind));
                   
                }

                //Get target fields
                PnP.AuthenticationManager authManagerTarget = new PnP.AuthenticationManager();
                ClientContext clientContextTarget = authManagerTarget.GetWebLoginClientContext(txtTargetList.Text);

                List TargetList = clientContextTarget.Web.Lists.GetByTitle(drpTargetLists.SelectedItem.ToString());
                // fetch the fields from this list
                FieldCollection targetFields = TargetList.Fields;
                clientContextTarget.Load(targetFields);
                clientContextTarget.ExecuteQuery();

                var targetColumns = new List<string> { "ID" };
                foreach (var f in targetFields)
                {
                    if (f.InternalName.StartsWith("_") || f.InternalName.StartsWith("ows"))
                    {
                       continue; // note: this will also skip the user created fields
                    }
targetColumns.Add(f.InternalName);
                }

                //Compare and remove same fields
                foreach (var col in targetColumns)
                {
                    try
                    {
                        sourceColumns.Remove(sourceColumns.First(item => item.Key.Equals(col)));
                    }
                    catch { }
                }

                DataTable dt = new DataTable();
                dt.Columns.Add("Missing Fields");
                dt.Columns.Add("Internal Name");
                dt.Columns.Add("Type");
                dt.Columns.Add("Create Missing Fields using below Name");
                DataRow dr;

                foreach (var col in sourceColumns)
                {
                    dr = dt.NewRow();
                    dr["Missing Fields"] = col.Value.ToString().Split('|')[0];
                    dr["Internal Name"] = col.Key;
                    dr["Type"] = col.Value.ToString().Split('|')[1];
                    dr["Create Missing Fields using below Name"] = System.Xml.XmlConvert.DecodeName(col.Key);
                    dt.Rows.Add(dr);
                }
                dataGridViewMissingFields.DataSource = null;
                dataGridViewMissingFields.DataSource = dt;
                dataGridViewMissingFields.Columns[0].Width = 150;
                dataGridViewMissingFields.Columns[1].Width = 150;
                dataGridViewMissingFields.Columns[2].Width = 80;
                dataGridViewMissingFields.Columns[3].Width = 240;
            }
            catch(Exception ex)
            {
                F.MessageBox.Show("Error: " + ex.Message);
            }
        }

How to decode SharePoint list field internal name?

System.Xml.XmlConvert.DecodeName("internal_name_of_field");