public GenericResponseVM CheckSecurityGroupInTeamMembers(Client client, Matter matter, IList<string> userId) { try { GenericResponseVM genericResponse = null; int securityGroupRowNumber = -1; // Blocked user field has security group List<Tuple<int, Principal>> teamMemberPrincipalCollection = new List<Tuple<int, Principal>>(); if (null != matter && null != matter.AssignUserNames && null != matter.BlockUserNames) { teamMemberPrincipalCollection = matterRespository.CheckUserSecurity(client, matter, userId); foreach (Tuple<int, Principal> teamMemberPrincipal in teamMemberPrincipalCollection) { Principal currentTeamMemberPrincipal = teamMemberPrincipal.Item2; if (currentTeamMemberPrincipal.PrincipalType == PrincipalType.SecurityGroup) { securityGroupRowNumber = teamMemberPrincipal.Item1; return ServiceUtility.GenericResponse(errorSettings.ErrorCodeSecurityGroupExists, errorSettings.ErrorMessageSecurityGroupExists + ServiceConstants.DOLLAR + userId[securityGroupRowNumber]); } } } else { return ServiceUtility.GenericResponse(errorSettings.IncorrectTeamMembersCode, errorSettings.IncorrectTeamMembersMessage); } return genericResponse; } catch (Exception) { throw; } }
/// <summary> /// This method will get all content types from the specified content type group and will filter out the content types that user has selected /// when creating the matter /// </summary> /// <param name="clientContext">The sharepoint context object</param> /// <param name="contentTypesNames">Content Type Names that user selected in the create matter screen</param> /// <param name="client">The client object which contains information for which client the matter is getting created and the url of the client</param> /// <param name="matter">The matter information that is getting created</param> /// <returns></returns> public IList<ContentType> GetContentTypeData(ClientContext clientContext, IList<string> contentTypesNames, Client client, Matter matter) { ContentTypeCollection contentTypeCollection = null; IList<ContentType> selectedContentTypeCollection = new List<ContentType>(); try { if (null != clientContext && null != contentTypesNames) { Web web = clientContext.Web; string contentTypeName = contentTypesConfig.OneDriveContentTypeGroup.Trim(); contentTypeCollection = web.ContentTypes; clientContext.Load(contentTypeCollection, contentType => contentType.Include(thisContentType => thisContentType.Name).Where(currContentType => currContentType.Group == contentTypeName)); clientContext.ExecuteQuery(); selectedContentTypeCollection = GetContentTypeList(contentTypesNames, contentTypeCollection.ToList()); } } catch (Exception exception) { customLogger.LogError(exception, MethodBase.GetCurrentMethod().DeclaringType.Name, MethodBase.GetCurrentMethod().Name, logTables.SPOLogTable); throw; } return selectedContentTypeCollection; }
/// <summary> /// Validates if there is at-least one user with full control in assign list. /// </summary> /// <param name="matter">Matter object</param> /// <returns>Status of Full Control permission</returns> public bool ValidateFullControlPermission(Matter matter) { bool hasFullConrol = false; if (null != matter && null != matter.Permissions && 0 != matter.Permissions.Count) { hasFullConrol = matter.Permissions.Contains(matterSettings.EditMatterAllowedPermissionLevel); } return hasFullConrol; }
public static List<Tuple<int, Principal>> GetUserPrincipal(ClientContext clientContext, Matter matter, IList<string> userIds) { List<Tuple<int, Principal>> teamMemberPrincipalCollection = new List<Tuple<int, Principal>>(); int securityGroupRowNumber = -1; try { int teamMembersRowCount = matter.AssignUserNames.Count; List<string> blockedUsers = matter.BlockUserNames.Where(user => !string.IsNullOrWhiteSpace(user.Trim())).ToList(); if (0 < teamMembersRowCount) { securityGroupRowNumber = -2; // Invalid user for (int iterator = 0; iterator < teamMembersRowCount; iterator++) { List<string> currentRowTeamMembers = matter.AssignUserNames[iterator].Where(user => !string.IsNullOrWhiteSpace(user.Trim())).ToList(); foreach (string teamMember in currentRowTeamMembers) { Principal teamMemberPrincipal = clientContext.Web.EnsureUser(teamMember); clientContext.Load(teamMemberPrincipal, teamMemberPrincipalProperties => teamMemberPrincipalProperties.PrincipalType, teamMemberPrincipalProperties => teamMemberPrincipalProperties.Title); teamMemberPrincipalCollection.Add(new Tuple<int, Principal>(iterator, teamMemberPrincipal)); } } } if (0 < blockedUsers.Count) { foreach (string blockedUser in blockedUsers) { Principal teamMemberPrincipal = clientContext.Web.EnsureUser(blockedUser); clientContext.Load(teamMemberPrincipal, teamMemberPrincipalProperties => teamMemberPrincipalProperties.PrincipalType, teamMemberPrincipalProperties => teamMemberPrincipalProperties.Title); teamMemberPrincipalCollection.Add(new Tuple<int, Principal>(-1, teamMemberPrincipal)); } } clientContext.ExecuteQuery(); return teamMemberPrincipalCollection; } catch (Exception ex) { //customLogger.LogError(ex, MethodBase.GetCurrentMethod().DeclaringType.Name, MethodBase.GetCurrentMethod().Name, logTables.SPOLogTable); throw; } }
/// <summary> /// This method will assign content types to the matter that is getting created /// </summary> /// <param name="matterMetadata"></param> /// <param name="clientContext"></param> /// <param name="contentTypeCollection"></param> /// <param name="client"></param> /// <param name="matter"></param> /// <returns></returns> public GenericResponseVM AssignContentTypeHelper(MatterMetadata matterMetadata, ClientContext clientContext, IList<ContentType> contentTypeCollection, Client client, Matter matter) { try { Web web = clientContext.Web; List matterList = web.Lists.GetByTitle(matter.Name); SetFieldValues(clientContext, contentTypeCollection, matterList, matterMetadata); clientContext.ExecuteQuery(); SetDefaultContentType(clientContext, matterList, client, matter); string[] viewColumnList = contentTypesConfig.ViewColumnList.Split(new string[] { ServiceConstants.SEMICOLON }, StringSplitOptions.RemoveEmptyEntries).Select(listEntry => listEntry.Trim()).ToArray(); string strQuery = string.Format(CultureInfo.InvariantCulture, camlQueries.ViewOrderByQuery, contentTypesConfig.ViewOrderByColumn); bool isViewCreated = spList.AddView(clientContext, matterList, viewColumnList, contentTypesConfig.ViewName, strQuery); return ServiceUtility.GenericResponse(string.Empty, Convert.ToString(isViewCreated, CultureInfo.CurrentCulture).ToLower(CultureInfo.CurrentCulture)); } catch (Exception exception) { customLogger.LogError(exception, MethodBase.GetCurrentMethod().DeclaringType.Name, MethodBase.GetCurrentMethod().Name, logTables.SPOLogTable); throw; } }
/// <summary> /// Converts the project users emails in a form that can be stamped to library. /// </summary> /// <param name="clientContext">ClientContext object</param> /// <param name="matter">Matter object</param> /// <returns>Users that can be stamped</returns> public static string GetMatterAssignedUsersEmail(ClientContext clientContext, Matter matter) { string currentUsers = string.Empty; string separator = string.Empty; if (null != matter && 0 < matter.AssignUserEmails.Count) { foreach (IList<string> userNames in matter.AssignUserEmails) { List<string> userEmails = new List<string>(); if (null != clientContext && null != userNames) { foreach (string userName in userNames) { if (!string.IsNullOrWhiteSpace(userName)) { if (Regex.IsMatch(userName.Trim(), "^[\\s]*\\w+([-+.']\\w+)*@\\w+([-.]\\w+)*\\.\\w+([-.]\\w+)*[\\s]*$", RegexOptions.IgnoreCase, TimeSpan.FromMilliseconds(250))) { userEmails.Add(userName); } else { User user = clientContext.Web.EnsureUser(userName.Trim()); ///// Only Fetch the User ID which is required clientContext.Load(user, u => u.Email); clientContext.ExecuteQuery(); ///// Add the user to the first element of the FieldUserValue array. userEmails.Add(user.Email); } } } currentUsers += separator + string.Join(ServiceConstants.SEMICOLON, userEmails); separator = ServiceConstants.DOLLAR + ServiceConstants.PIPE + ServiceConstants.DOLLAR; } } } return currentUsers; }
/// <summary> /// Function to create dictionary object for stamp property /// </summary> /// <param name="client">Client object containing Client data</param> /// <param name="matter">Matter object containing Matter data</param> /// <param name="matterDetails">Matter details object which has data of properties to be stamped</param> /// <returns>returns dictionary object</returns> internal Dictionary<string, string> SetStampProperty(Client client, Matter matter, MatterDetails matterDetails) { string matterCenterPermission = string.Join(ServiceConstants.DOLLAR + ServiceConstants.PIPE + ServiceConstants.DOLLAR, matter.Permissions); string matterCenterRoles = string.Join(ServiceConstants.DOLLAR + ServiceConstants.PIPE + ServiceConstants.DOLLAR, matter.Roles); string documentTemplateCount = string.Join(ServiceConstants.DOLLAR + ServiceConstants.PIPE + ServiceConstants.DOLLAR, matter.DocumentTemplateCount); string matterCenterUsers = string.Empty; string separator = string.Empty; foreach (IList<string> userNames in matter.AssignUserNames) { matterCenterUsers += separator + string.Join(ServiceConstants.SEMICOLON, userNames.Where(user => !string.IsNullOrWhiteSpace(user))); separator = ServiceConstants.DOLLAR + ServiceConstants.PIPE + ServiceConstants.DOLLAR; } List<string> keys = new List<string>(); Dictionary<string, string> propertyList = new Dictionary<string, string>(); keys.Add(matterSettings.StampedPropertyPracticeGroup); keys.Add(matterSettings.StampedPropertyAreaOfLaw); keys.Add(matterSettings.StampedPropertySubAreaOfLaw); keys.Add(matterSettings.StampedPropertyMatterName); keys.Add(matterSettings.StampedPropertyMatterID); keys.Add(matterSettings.StampedPropertyClientName); keys.Add(matterSettings.StampedPropertyClientID); keys.Add(matterSettings.StampedPropertyResponsibleAttorney); keys.Add(matterSettings.StampedPropertyTeamMembers); keys.Add(matterSettings.StampedPropertyIsMatter); keys.Add(matterSettings.StampedPropertyOpenDate); keys.Add(matterSettings.StampedPropertySecureMatter); keys.Add(matterSettings.StampedPropertyBlockedUploadUsers); keys.Add(matterSettings.StampedPropertyMatterDescription); keys.Add(matterSettings.StampedPropertyConflictCheckDate); keys.Add(matterSettings.StampedPropertyConflictCheckBy); keys.Add(matterSettings.StampedPropertyMatterCenterRoles); keys.Add(matterSettings.StampedPropertyMatterCenterPermissions); keys.Add(matterSettings.StampedPropertyMatterCenterUsers); keys.Add(matterSettings.StampedPropertyDefaultContentType); keys.Add(matterSettings.StampedPropertyIsConflictIdentified); keys.Add(matterSettings.StampedPropertyDocumentTemplateCount); keys.Add(matterSettings.StampedPropertyBlockedUsers); keys.Add(matterSettings.StampedPropertyMatterGUID); propertyList.Add(matterSettings.StampedPropertyPracticeGroup, WebUtility.HtmlEncode(matterDetails.PracticeGroup)); propertyList.Add(matterSettings.StampedPropertyAreaOfLaw, WebUtility.HtmlEncode(matterDetails.AreaOfLaw)); propertyList.Add(matterSettings.StampedPropertySubAreaOfLaw, WebUtility.HtmlEncode(matterDetails.SubareaOfLaw)); propertyList.Add(matterSettings.StampedPropertyMatterName, WebUtility.HtmlEncode(matter.Name)); propertyList.Add(matterSettings.StampedPropertyMatterID, WebUtility.HtmlEncode(matter.Id)); propertyList.Add(matterSettings.StampedPropertyClientName, WebUtility.HtmlEncode(client.Name)); propertyList.Add(matterSettings.StampedPropertyClientID, WebUtility.HtmlEncode(client.Id)); propertyList.Add(matterSettings.StampedPropertyResponsibleAttorney, WebUtility.HtmlEncode(matterDetails.ResponsibleAttorney)); propertyList.Add(matterSettings.StampedPropertyTeamMembers, WebUtility.HtmlEncode(matterDetails.TeamMembers)); propertyList.Add(matterSettings.StampedPropertyIsMatter, ServiceConstants.TRUE); propertyList.Add(matterSettings.StampedPropertyOpenDate, WebUtility.HtmlEncode(DateTime.Now.ToString(matterSettings.ValidDateFormat, CultureInfo.InvariantCulture))); propertyList.Add(matterSettings.PropertyNameVtiIndexedPropertyKeys, WebUtility.HtmlEncode(ServiceUtility.GetEncodedValueForSearchIndexProperty(keys))); propertyList.Add(matterSettings.StampedPropertySecureMatter, (matter.Conflict != null) ? (matter.Conflict.SecureMatter != null) ? WebUtility.HtmlEncode(matter.Conflict.SecureMatter) : "False" : "False"); propertyList.Add(matterSettings.StampedPropertyBlockedUploadUsers, WebUtility.HtmlEncode(string.Join(";", matterDetails.UploadBlockedUsers))); propertyList.Add(matterSettings.StampedPropertyMatterDescription, WebUtility.HtmlEncode(matter.Description)); propertyList.Add(matterSettings.StampedPropertyConflictCheckDate, (string.IsNullOrEmpty(matter.Conflict.CheckOn)) ? "" : WebUtility.HtmlEncode(Convert.ToDateTime(matter.Conflict.CheckOn, CultureInfo.InvariantCulture).ToString(matterSettings.ValidDateFormat, CultureInfo.InvariantCulture))); propertyList.Add(matterSettings.StampedPropertyConflictCheckBy, WebUtility.HtmlEncode(matter.Conflict.CheckBy)); propertyList.Add(matterSettings.StampedPropertyMatterCenterRoles, WebUtility.HtmlEncode(matterCenterRoles)); propertyList.Add(matterSettings.StampedPropertyMatterCenterPermissions, WebUtility.HtmlEncode(matterCenterPermission)); propertyList.Add(matterSettings.StampedPropertyMatterCenterUsers, WebUtility.HtmlEncode(matterCenterUsers)); propertyList.Add(matterSettings.StampedPropertyDefaultContentType, WebUtility.HtmlEncode(matter.DefaultContentType)); propertyList.Add(matterSettings.StampedPropertyIsConflictIdentified, WebUtility.HtmlEncode(matter.Conflict.Identified)); propertyList.Add(matterSettings.StampedPropertyDocumentTemplateCount, WebUtility.HtmlEncode(documentTemplateCount)); propertyList.Add(matterSettings.StampedPropertyBlockedUsers, WebUtility.HtmlEncode(string.Join(";", matter.BlockUserNames))); propertyList.Add(matterSettings.StampedPropertyMatterGUID, WebUtility.HtmlEncode(matter.MatterGuid)); propertyList.Add(matterSettings.StampedPropertySuccess, ServiceConstants.TRUE); return propertyList; }
/// <summary> /// Configures XML of web parts. /// </summary> /// <param name="requestObject">Request Object</param> /// <param name="client">Client object containing Client data</param> /// <param name="matter">Matter object containing Matter data</param> /// <param name="clientContext">SharePoint Client Context</param> /// <param name="sitePageLib">SharePoint List of matter library</param> /// <param name="objFileInfo">Object of FileCreationInformation</param> /// <param name="uri">To get URL segments</param> /// <param name="web">Web object of the current context</param> /// <returns>List of Web Parts</returns> public string[] ConfigureXMLCodeOfWebParts(Client client, Matter matter, ClientContext clientContext, string pageName, Uri uri, Web web, MatterConfigurations matterConfigurations) { string[] result = null; try { List sitePageLib = web.Lists.GetByTitle(matter.Name); clientContext.Load(sitePageLib); clientContext.ExecuteQuery(); ////Configure list View Web Part XML string listViewWebPart = ConfigureListViewWebPart(sitePageLib, clientContext, pageName, client, matter, string.Format(CultureInfo.InvariantCulture, "{0}{1}{2}{3}{4}", uri.AbsolutePath, ServiceConstants.FORWARD_SLASH, matter.Name, ServiceConstants.FORWARD_SLASH, pageName)); string[] contentEditorSectionIds = matterSettings.MatterLandingPageSections.Split(Convert.ToChar(ServiceConstants.COMMA, CultureInfo.InvariantCulture)); ////Configure content Editor Web Part of user information XML string contentEditorWebPartTasks = string.Empty; if (matterConfigurations.IsTaskSelected) { contentEditorWebPartTasks = string.Format(CultureInfo.InvariantCulture, ServiceConstants.CONTENT_EDITOR_WEB_PART, string.Format(CultureInfo.InvariantCulture, ServiceConstants.MATTER_LANDING_SECTION_CONTENT, contentEditorSectionIds[Convert.ToInt32(MatterLandingSection.TaskPanel, CultureInfo.InvariantCulture)])); } string calendarWebpart = string.Empty, rssFeedWebPart = string.Empty, rssTitleWebPart = string.Empty; if (matterConfigurations.IsRSSSelected) { rssFeedWebPart = string.Format(CultureInfo.InvariantCulture, ServiceConstants.RSS_FEED_WEB_PART, WebUtility.UrlEncode(matter.Name)); rssTitleWebPart = string.Format(CultureInfo.InvariantCulture, ServiceConstants.CONTENT_EDITOR_WEB_PART, string.Format(CultureInfo.InvariantCulture, ServiceConstants.MATTER_LANDING_SECTION_CONTENT, contentEditorSectionIds[Convert.ToInt32(MatterLandingSection.RSSTitlePanel, CultureInfo.InvariantCulture)])); } ////Configure calendar Web Part XML if (matterConfigurations.IsCalendarSelected) { ////If create calendar is enabled configure calendar Web Part XML; else dont configure calendarWebpart = string.Format(CultureInfo.InvariantCulture, ServiceConstants.CONTENT_EDITOR_WEB_PART, string.Format(CultureInfo.InvariantCulture, ServiceConstants.MATTER_LANDING_SECTION_CONTENT, contentEditorSectionIds[Convert.ToInt32(MatterLandingSection.CalendarPanel, CultureInfo.InvariantCulture)])); } string matterInformationSection = string.Format(CultureInfo.InvariantCulture, ServiceConstants.CONTENT_EDITOR_WEB_PART, string.Format(CultureInfo.InvariantCulture, ServiceConstants.MATTER_LANDING_SECTION_CONTENT, contentEditorSectionIds[Convert.ToInt32(MatterLandingSection.InformationPanel, CultureInfo.InvariantCulture)])); string cssLink = string.Format(CultureInfo.InvariantCulture, matterSettings.MatterLandingCSSFileName, matterSettings.MatterLandingFolderName); string commonCssLink = string.Format(CultureInfo.InvariantCulture, matterSettings.CommonCSSFileLink, matterSettings.CommonFolderName); string jsLinkMatterLandingPage = string.Format(CultureInfo.InvariantCulture, matterSettings.MatterLandingJSFileName, matterSettings.MatterLandingFolderName); string jsLinkJQuery = string.Format(CultureInfo.InvariantCulture, matterSettings.JQueryFileName, matterSettings.CommonFolderName); string jsLinkCommon = string.Format(CultureInfo.InvariantCulture, matterSettings.CommonJSFileLink, matterSettings.CommonFolderName); string headerWebPartSection = string.Format(CultureInfo.InvariantCulture, ServiceConstants.MATTER_LANDING_SECTION_CONTENT, contentEditorSectionIds[Convert.ToInt32(MatterLandingSection.HeaderPanel, CultureInfo.InvariantCulture)]); string footerWebPartSection = string.Format(CultureInfo.InvariantCulture, ServiceConstants.MATTER_LANDING_SECTION_CONTENT, contentEditorSectionIds[Convert.ToInt32(MatterLandingSection.FooterPanel, CultureInfo.InvariantCulture)]); headerWebPartSection = string.Concat(string.Format(CultureInfo.InvariantCulture, ServiceConstants.STYLE_TAG, cssLink), headerWebPartSection); headerWebPartSection = string.Concat(string.Format(CultureInfo.InvariantCulture, ServiceConstants.STYLE_TAG, commonCssLink), headerWebPartSection); headerWebPartSection = string.Concat(string.Format(CultureInfo.InvariantCulture, ServiceConstants.SCRIPT_TAG_WITH_CONTENTS, string.Format(CultureInfo.InvariantCulture, ServiceConstants.MATTER_LANDING_STAMP_PROPERTIES, matter.Name, matter.MatterGuid)), headerWebPartSection); footerWebPartSection = string.Concat(string.Format(CultureInfo.InvariantCulture, ServiceConstants.SCRIPT_TAG, jsLinkMatterLandingPage), footerWebPartSection); footerWebPartSection = string.Concat(string.Format(CultureInfo.InvariantCulture, ServiceConstants.SCRIPT_TAG, jsLinkCommon), footerWebPartSection); footerWebPartSection = string.Concat(string.Format(CultureInfo.InvariantCulture, ServiceConstants.SCRIPT_TAG, jsLinkJQuery), footerWebPartSection); string headerWebPart = string.Format(CultureInfo.InvariantCulture, ServiceConstants.CONTENT_EDITOR_WEB_PART, headerWebPartSection); string footerWebPart = string.Format(CultureInfo.InvariantCulture, ServiceConstants.CONTENT_EDITOR_WEB_PART, footerWebPartSection); string oneNoteWebPart = string.Format(CultureInfo.InvariantCulture, ServiceConstants.CONTENT_EDITOR_WEB_PART, string.Format(CultureInfo.InvariantCulture, ServiceConstants.MATTER_LANDING_SECTION_CONTENT, contentEditorSectionIds[Convert.ToInt32(MatterLandingSection.OneNotePanel, CultureInfo.InvariantCulture)])); string[] webParts = { headerWebPart, matterInformationSection, oneNoteWebPart, listViewWebPart, rssFeedWebPart, rssTitleWebPart, footerWebPart, calendarWebpart, contentEditorWebPartTasks }; result = webParts; } catch (Exception exception) { customLogger.LogError(exception, MethodBase.GetCurrentMethod().DeclaringType.Name, MethodBase.GetCurrentMethod().Name, logTables.SPOLogTable); throw; } return result; }
/// <summary> /// Validates the permissions assigned to the users. /// </summary> /// <param name="matter">Matter object containing Matter data</param> /// <returns>A string value indicating whether validations passed or fail</returns> private GenericResponseVM CheckUserPermission(Matter matter) { if (0 >= matter.Permissions.Count()) { return GenericResponse(errorSettings.IncorrectInputUserPermissionsCode, errorSettings.IncorrectInputUserPermissionsMessage); } else { string userAllowedPermissions = matterSettings.UserPermissions; if (!string.IsNullOrEmpty(userAllowedPermissions)) { List<string> userPermissions = userAllowedPermissions.ToUpperInvariant().Trim().Split(new string[] { "," }, StringSplitOptions.RemoveEmptyEntries).ToList(); foreach (string Permissions in matter.Permissions) { if (!userPermissions.Contains(Permissions.Trim().ToUpperInvariant())) { return GenericResponse(errorSettings.IncorrectInputUserPermissionsCode, errorSettings.IncorrectInputUserPermissionsMessage); } } } } return null; }
/// <summary> /// Generates list of users for sending email. /// </summary> /// <param name="matter">Matter details</param> /// <param name="clientContext">SharePoint client context</param> /// <param name="userList">List of users associated with the matter</param> /// <returns>List of users to whom mail is to be sent</returns> internal List<FieldUserValue> GenerateMailList(Matter matter, Client client, ref List<FieldUserValue> userList) { List<FieldUserValue> result = null; try { List<FieldUserValue> userEmailList = new List<FieldUserValue>(); if (null != matter.AssignUserNames) { foreach (IList<string> userNames in matter.AssignUserNames) { userList = matterRepositoy.ResolveUserNames(client, userNames).ToList(); foreach (FieldUserValue userEmail in userList) { userEmailList.Add(userEmail); } } } result = userEmailList; } catch (Exception exception) { customLogger.LogError(exception, MethodBase.GetCurrentMethod().DeclaringType.Name, MethodBase.GetCurrentMethod().Name, logTables.SPOLogTable); throw; } return result; }
/// <summary> /// This method will save matter configurations in sharepoint list /// </summary> /// <param name="matterConfigurations"></param> /// <returns></returns> public GenericResponseVM SaveConfigurations(MatterConfigurations matterConfigurations) { try { Matter matter = new Matter(); matter.AssignUserNames = GetUserList(matterConfigurations.MatterUsers); matter.AssignUserEmails = GetUserList(matterConfigurations.MatterUserEmails); ClientContext clientContext = null; clientContext = spoAuthorization.GetClientContext(matterConfigurations.ClientUrl); GenericResponseVM genericResponseVM = null; if (0 < matter.AssignUserNames.Count) { genericResponseVM = matterRepositoy.ValidateTeamMembers(clientContext, matter, matterConfigurations.UserId); } if (genericResponseVM != null) { return genericResponseVM; } genericResponseVM = matterRepositoy.SaveConfigurations(clientContext, matterConfigurations); return genericResponseVM; } catch (Exception ex) { customLogger.LogError(ex, MethodBase.GetCurrentMethod().DeclaringType.Name, MethodBase.GetCurrentMethod().Name, logTables.SPOLogTable); throw; } }
/// <summary> /// Reverts the permission of users from matter, OneNote, Calendar libraries and matter landing page /// </summary> /// <param name="requestObject">Request object</param> /// <param name="client">Client object</param> /// <param name="matter">Matter object</param> /// <param name="clientContext">ClientContext object</param> /// <param name="matterRevertListObject">MatterRevertObjectList object</param> /// <param name="loggedInUserTitle">Logged-in user title</param> /// <param name="oldUserPermissions">Old library users</param> /// <param name="matterLandingPageId">List item id</param> /// <param name="isEditMode">Add/ Edit mode</param> /// <returns>Status of operation</returns> public bool RevertMatterUpdates(Client client, Matter matter, ClientContext clientContext, MatterRevertList matterRevertListObject, string loggedInUserTitle, IEnumerable<RoleAssignment> oldUserPermissions, int matterLandingPageId, bool isEditMode) { bool result = false; try { if (null != client && null != matter && null != clientContext && null != matterRevertListObject) { List<string> users = new List<string>(); users = matter.AssignUserNames.SelectMany(user => user).Distinct().ToList(); // Remove recently added users if (null != matterRevertListObject.MatterLibrary) { SPList.RemoveSpecificUsers(clientContext, users, loggedInUserTitle, false, matterRevertListObject.MatterLibrary, -1); } if (null != matterRevertListObject.MatterCalendar) { SPList.RemoveSpecificUsers(clientContext, users, loggedInUserTitle, false, matterRevertListObject.MatterCalendar, -1); } if (null != matterRevertListObject.MatterOneNoteLibrary) { SPList.RemoveSpecificUsers(clientContext, users, loggedInUserTitle, false, matterRevertListObject.MatterOneNoteLibrary, -1); } if (null != matterRevertListObject.MatterTask) { SPList.RemoveSpecificUsers(clientContext, users, loggedInUserTitle, false, matterRevertListObject.MatterTask, -1); } if (null != matterRevertListObject.MatterSitePages) { SPList.RemoveSpecificUsers(clientContext, users, loggedInUserTitle, true, matterRevertListObject.MatterSitePages, matterLandingPageId); } if (isEditMode) { Matter matterRevertUserPermission = PrepareUserPermission(oldUserPermissions); if (null != matterRevertListObject.MatterLibrary) { result = SPList.SetPermission(clientContext, matterRevertUserPermission.AssignUserNames, matterRevertUserPermission.Permissions, matterRevertListObject.MatterLibrary); } if (null != matterRevertListObject.MatterOneNoteLibrary) { result = SPList.SetPermission(clientContext, matterRevertUserPermission.AssignUserNames, matterRevertUserPermission.Permissions, matterRevertListObject.MatterOneNoteLibrary); } if (null != matterRevertListObject.MatterCalendar) { result = SPList.SetPermission(clientContext, matterRevertUserPermission.AssignUserNames, matterRevertUserPermission.Permissions, matterRevertListObject.MatterCalendar); } if (null != matterRevertListObject.MatterTask) { result = SPList.SetPermission(clientContext, matterRevertUserPermission.AssignUserNames, matterRevertUserPermission.Permissions, matterRevertListObject.MatterTask); } if (null != matterRevertListObject.MatterSitePages && 0 <= matterLandingPageId) { result = SPList.SetItemPermission(clientContext, matterRevertUserPermission.AssignUserNames, "Site Pages", matterLandingPageId, matterRevertUserPermission.Permissions); } } } return result; } catch (Exception exception) { //Logger.LogError(exception, MethodBase.GetCurrentMethod().DeclaringType.Name, MethodBase.GetCurrentMethod().Name, ServiceConstants.LogTableName); } // To avoid the invalid symbol error while parsing the JSON, return the response in lower case return result; }
/// <summary> /// Converts the matter users in a form that can be stamped to library. /// </summary> /// <param name="matter">Matter object</param> /// <returns>Users that can be stamped</returns> private string GetMatterAssignedUsers(Matter matter) { string currentUsers = string.Empty; string separator = string.Empty; if (null != matter && 0 < matter.AssignUserNames.Count) { foreach (IList<string> userNames in matter.AssignUserNames) { currentUsers += separator + string.Join(ServiceConstants.SEMICOLON, userNames.Where(user => !string.IsNullOrWhiteSpace(user))); separator = ServiceConstants.DOLLAR + ServiceConstants.PIPE + ServiceConstants.DOLLAR; } } return currentUsers; }
public bool UpdateMatterStampedProperties(ClientContext clientContext, MatterDetails matterDetails, Matter matter, PropertyValues matterStampedProperties, bool isEditMode, IConfigurationRoot configuration) { try { if (null != clientContext && null != matter && null != matterDetails && (0 < matterStampedProperties.FieldValues.Count)) { Dictionary<string, string> propertyList = new Dictionary<string, string>(); // Get existing stamped properties string stampedUsers = GetStampPropertyValue(matterStampedProperties.FieldValues, configuration["Matter:StampedPropertyMatterCenterUsers"]); string stampedUserEmails = GetStampPropertyValue(matterStampedProperties.FieldValues, configuration["Matter:StampedPropertyMatterCenterUserEmails"]); string stampedPermissions = GetStampPropertyValue(matterStampedProperties.FieldValues, configuration["Matter:StampedPropertyMatterCenterPermissions"]); string stampedRoles = GetStampPropertyValue(matterStampedProperties.FieldValues, configuration["Matter:StampedPropertyMatterCenterRoles"]); string stampedResponsibleAttorneys = GetStampPropertyValue(matterStampedProperties.FieldValues, configuration["Matter:StampedPropertyResponsibleAttorney"]); string stampedResponsibleAttorneysEmail = GetStampPropertyValue(matterStampedProperties.FieldValues, configuration["Matter:StampedPropertyResponsibleAttorneyEmail"]); string stampedTeamMembers = GetStampPropertyValue(matterStampedProperties.FieldValues, configuration["Matter:StampedPropertyTeamMembers"]); string stampedBlockedUploadUsers = GetStampPropertyValue(matterStampedProperties.FieldValues, configuration["Matter:StampedPropertyBlockedUploadUsers"]); string currentPermissions = string.Join(ServiceConstants.DOLLAR + ServiceConstants.PIPE + ServiceConstants.DOLLAR, matter.Permissions.Where(user => !string.IsNullOrWhiteSpace(user))); string currentRoles = string.Join(ServiceConstants.DOLLAR + ServiceConstants.PIPE + ServiceConstants.DOLLAR, matter.Roles.Where(user => !string.IsNullOrWhiteSpace(user))); string currentBlockedUploadUsers = string.Join(ServiceConstants.SEMICOLON, matterDetails.UploadBlockedUsers.Where(user => !string.IsNullOrWhiteSpace(user))); string currentUsers = GetMatterAssignedUsers(matter); string currentUserEmails = SPList.GetMatterAssignedUsersEmail(clientContext, matter); string finalMatterPermissions = string.Concat(stampedPermissions, ServiceConstants.DOLLAR + ServiceConstants.PIPE + ServiceConstants.DOLLAR, currentPermissions); string finalMatterRoles = string.Concat(stampedRoles, ServiceConstants.DOLLAR + ServiceConstants.PIPE + ServiceConstants.DOLLAR, currentRoles); string finalTeamMembers = string.Concat(stampedTeamMembers, ServiceConstants.SEMICOLON, ServiceConstants.SEMICOLON, matterDetails.TeamMembers); string finalMatterCenterUsers = string.Concat(stampedUsers, ServiceConstants.DOLLAR + ServiceConstants.PIPE + ServiceConstants.DOLLAR, currentUsers); string finalBlockedUploadUsers = string.Concat(stampedBlockedUploadUsers, ServiceConstants.SEMICOLON, currentBlockedUploadUsers); //if(stampedUserEmails.LastIndexOf("$|$")>0) //{ // stampedUserEmails = stampedUserEmails.Remove(stampedUserEmails.Length - 3); //} string finalMatterCenterUserEmails = string.Concat(stampedUserEmails, ServiceConstants.DOLLAR + ServiceConstants.PIPE + ServiceConstants.DOLLAR, currentUserEmails); string finalResponsibleAttorneysEmail = ""; string finalResponsibleAttorneys = ""; if (matterDetails.ResponsibleAttorneyEmail!=null) { finalResponsibleAttorneysEmail = string.IsNullOrWhiteSpace(stampedResponsibleAttorneysEmail) || isEditMode ? matterDetails.ResponsibleAttorneyEmail : string.Concat(stampedResponsibleAttorneysEmail, ServiceConstants.SEMICOLON, matterDetails.ResponsibleAttorneyEmail); finalResponsibleAttorneys = string.IsNullOrWhiteSpace(stampedResponsibleAttorneys) || isEditMode ? matterDetails.ResponsibleAttorney : string.Concat(stampedResponsibleAttorneys, ServiceConstants.SEMICOLON, matterDetails.ResponsibleAttorney); } else { finalResponsibleAttorneysEmail = stampedResponsibleAttorneysEmail; finalResponsibleAttorneys = stampedResponsibleAttorneys; } propertyList.Add(configuration["Matter:StampedPropertyResponsibleAttorney"], WebUtility.HtmlEncode(finalResponsibleAttorneys)); propertyList.Add(configuration["Matter:StampedPropertyResponsibleAttorneyEmail"], WebUtility.HtmlEncode(finalResponsibleAttorneysEmail)); propertyList.Add(configuration["Matter:StampedPropertyTeamMembers"], WebUtility.HtmlEncode(finalTeamMembers)); propertyList.Add(configuration["Matter:StampedPropertyBlockedUploadUsers"], WebUtility.HtmlEncode(finalBlockedUploadUsers)); propertyList.Add(configuration["Matter:StampedPropertyMatterCenterRoles"], WebUtility.HtmlEncode(finalMatterRoles)); propertyList.Add(configuration["Matter:StampedPropertyMatterCenterPermissions"], WebUtility.HtmlEncode(finalMatterPermissions)); propertyList.Add(configuration["Matter:StampedPropertyMatterCenterUsers"], WebUtility.HtmlEncode(finalMatterCenterUsers)); propertyList.Add(configuration["Matter:StampedPropertyMatterCenterUserEmails"], WebUtility.HtmlEncode(finalMatterCenterUserEmails)); SPList.SetPropertBagValuesForList(clientContext, matterStampedProperties, matter.Name, propertyList); return true; } } catch (Exception) { throw; //// This will transfer control to catch block of parent function. } return false; }
/// <summary> /// Function to check user full permission on document library /// </summary> /// <param name="clientContext"></param> /// <param name="matter"></param> /// <returns></returns> public bool CheckUserFullPermission(ClientContext clientContext, Matter matter) { bool result = false; try { if (null != matter) { Web web = clientContext.Web; List list = web.Lists.GetByTitle(matter.Name); Users userDetails = GetLoggedInUserDetails(clientContext); Principal userPrincipal = web.EnsureUser(userDetails.Name); RoleAssignment userRole = list.RoleAssignments.GetByPrincipal(userPrincipal); clientContext.Load(userRole, userRoleProperties => userRoleProperties.Member, userRoleProperties => userRoleProperties.RoleDefinitionBindings.Include(userRoleDefinition => userRoleDefinition.Name).Where(userRoleDefinitionName => userRoleDefinitionName.Name == matterSettings.EditMatterAllowedPermissionLevel)); clientContext.ExecuteQuery(); if (0 < userRole.RoleDefinitionBindings.Count) { result = true; } } return result; } catch (Exception ex) { customLogger.LogError(ex, MethodBase.GetCurrentMethod().DeclaringType.Name, MethodBase.GetCurrentMethod().Name, logTables.SPOLogTable); throw; } }
public GenericResponseVM SavConfigurations(MatterConfigurations matterConfiguration) { ClientContext clientContext = null; GenericResponseVM returnFlag = null; try { clientContext = spoAuthorization.GetClientContext(matterConfiguration.ClientUrl); Matter matter = new Matter(); matter.AssignUserNames = GetUserList(matterConfiguration.MatterUsers); matter.AssignUserEmails = GetUserList(matterConfiguration.MatterUserEmails); if (0 < matter.AssignUserNames.Count) { returnFlag = matterRepositoy.ValidateTeamMembers(clientContext, matter, matterConfiguration.UserId); } if (returnFlag != null) { returnFlag = matterRepositoy.SaveConfigurationToList(matterConfiguration, clientContext, matterConfiguration.CachedItemModifiedDate); bool tempResult = false; if (returnFlag != null) { tempResult = bool.Parse(returnFlag.Value); if (tempResult) { string listQuery = string.Format(CultureInfo.InvariantCulture, camlQueries.MatterConfigurationsListQuery, searchSettings.ManagedPropertyTitle, searchSettings.MatterConfigurationTitleValue); ListItem settingsItem = matterRepositoy.GetItem(clientContext, listNames.MatterConfigurationsList, listQuery); if (null != settingsItem) { matterConfiguration.CachedItemModifiedDate = Convert.ToString(settingsItem[matterSettings.ColumnNameModifiedDate], CultureInfo.InvariantCulture); } returnFlag.Value = string.Concat(returnFlag.Value, ServiceConstants.PIPE, ServiceConstants.DOLLAR, ServiceConstants.PIPE, matterConfiguration.CachedItemModifiedDate); } } } return returnFlag; } catch (Exception ex) { customLogger.LogError(ex, MethodBase.GetCurrentMethod().DeclaringType.Name, MethodBase.GetCurrentMethod().Name, logTables.SPOLogTable); throw; } }
/// <summary> /// This method will loop for all external users in the matterinformation object and /// will send notification to that external user /// </summary> /// <param name="matterInformation">Contains information about all external users, his roles and permissions</param> private void ShareMatterToExtUser(MatterInformationVM matterInformation) { //index is used to get the individual assigned user permissions and roles var index = 0; for (int i = 0; i < matterInformation.Matter.AssignUserNames.Count; i++) { //Need to construct new MatterInformationVM object for each external user MatterInformationVM matterInfoNew = new MatterInformationVM(); //looping to send the notification to all the users present in matterInformation.Matter.AssignUserNames[i] for (int j = 0; j < matterInformation.Matter.AssignUserNames[i].Count; j++) { List<string> userIds = new List<string>(); if (matterInformation.UserIds != null) { foreach (var userid in matterInformation.UserIds) { userIds.Add(userid); } } matterInfoNew.UserIds = userIds; Conflict conflictNew = new Conflict(); conflictNew.Identified = matterInformation.Matter.Conflict.Identified; Matter matterNew = new Matter() { Id = matterInformation.Matter.Id, Name = matterInformation.Matter.Name, Description = matterInformation.Matter.Description, MatterGuid = matterInformation.Matter.MatterGuid, Conflict = conflictNew, }; matterInfoNew.EditMode = matterInformation.EditMode; matterInfoNew.Client = matterInformation.Client; var roles = new List<String>(); string role = matterInformation.Matter.Roles[index]; roles.Add(role); matterNew.Roles = roles; var permissions = new List<String>(); string permission = matterInformation.Matter.Permissions[index]; permissions.Add(permission); matterNew.Permissions = permissions; var assignUserEmails = new List<IList<string>>(); var userEmails = new List<string>(); var assignUserEmailList = matterInformation.Matter.AssignUserEmails[i]; var assignUserEmail = assignUserEmailList[j]; userEmails.Add(assignUserEmail); assignUserEmails.Add(userEmails); matterNew.AssignUserEmails = assignUserEmails; var assignUserNames = new List<IList<string>>(); var userNames = new List<string>(); var assignUserNameList = matterInformation.Matter.AssignUserNames[i]; var assignName = assignUserNameList[j]; userNames.Add(assignName); assignUserNames.Add(userNames); matterNew.AssignUserNames = assignUserNames; matterInfoNew.Matter = matterNew; MatterDetails matterDetailsNew = new MatterDetails(); if (!string.IsNullOrEmpty(matterInformation.MatterDetails.ResponsibleAttorney)) { matterDetailsNew.ResponsibleAttorney = matterInformation.MatterDetails.ResponsibleAttorney; } if (!string.IsNullOrEmpty(matterInformation.MatterDetails.ResponsibleAttorneyEmail)) { matterDetailsNew.ResponsibleAttorneyEmail = matterInformation.MatterDetails.ResponsibleAttorneyEmail; } matterDetailsNew.TeamMembers = assignName; matterDetailsNew.UploadBlockedUsers = matterInformation.MatterDetails.UploadBlockedUsers; matterInfoNew.MatterDetails = matterDetailsNew; //Share the matter to external user by sending the notification externalSharing.ShareMatter(matterInfoNew); index = index + 1; } } }
public static List<Tuple<int, Principal>> CheckUserSecurity(ClientContext clientContext, Matter matter, IList<string> userIds) { List<Tuple<int, Principal>> teamMemberPrincipalCollection = GetUserPrincipal(clientContext, matter, userIds); return teamMemberPrincipalCollection; }
/// <summary> /// Validates the roles for the matter and returns the validation status. /// </summary> /// <param name="requestObject">Request Object containing SharePoint App Token</param> /// <param name="matter">Matter object containing Matter data</param> /// <param name="client">Client Object</param> /// <returns>A string value indicating whether validations passed or fail</returns> internal GenericResponseVM RoleCheck(Matter matter) { GenericResponseVM genericResponse = null; try { if ( matter.Roles.Count()<=0) { return GenericResponse(errorSettings.IncorrectInputUserRolesCode, errorSettings.IncorrectInputUserRolesMessage); } IList<string> roles = matterRespository.RoleCheck(matterSettings.CentralRepositoryUrl, listNames.DMSRoleListName, camlQueries.DMSRoleQuery); if (matter.Roles.Except(roles).Count() > 0) { return GenericResponse(errorSettings.IncorrectInputUserRolesCode, errorSettings.IncorrectInputUserRolesMessage); } return genericResponse; } catch (Exception exception) { //ToDo: Why in role check function, we are deleting the matter //ProvisionHelperFunctions.DeleteMatter(requestObject, client, matter); //returnValue = Logger.LogError(exception, MethodBase.GetCurrentMethod().DeclaringType.Name, MethodBase.GetCurrentMethod().Name, ServiceConstantStrings.LogTableName); throw; } }
/// <summary> /// Validates the matter name. /// </summary> /// <param name="matter">Matter details</param> /// <returns>Matter details validation result</returns> private GenericResponseVM MatterNameValidation(Matter matter) { GenericResponseVM genericResponseVM = null; string matterNameValidation = string.Empty; if (string.IsNullOrWhiteSpace(matter.Name)) { return GenericResponse(errorSettings.IncorrectInputMatterNameCode, errorSettings.IncorrectInputMatterNameMessage); } var matterName = Regex.Match(matter.Name, matterSettings.SpecialCharacterExpressionMatterTitle, RegexOptions.IgnoreCase); if (int.Parse(matterSettings.MatterNameLength, CultureInfo.InvariantCulture) < matter.Name.Length || matter.Name.Length != matterName.Length) { return GenericResponse(errorSettings.IncorrectInputMatterNameCode, errorSettings.IncorrectInputMatterNameMessage); } return genericResponseVM; }
/// <summary> /// Fetches the users to remove permission. /// </summary> /// <param name="userPermissions">Users having permission on library</param> /// <returns>Matter object containing user name and permissions</returns> internal Matter PrepareUserPermission(IEnumerable<RoleAssignment> userPermissions) { Matter matterUserPermission = new Matter(); matterUserPermission.AssignUserNames = new List<IList<string>>(); matterUserPermission.Permissions = new List<string>(); if (null != userPermissions && 0 < userPermissions.Count()) { foreach (RoleAssignment userPermission in userPermissions) { foreach (RoleDefinition roleDefinition in userPermission.RoleDefinitionBindings) { matterUserPermission.AssignUserNames.Add(new List<string> { userPermission.Member.Title }); matterUserPermission.Permissions.Add(roleDefinition.Name); } } } return matterUserPermission; }
/// <summary> /// Function to share the matter. /// </summary> /// <param name="requestObject">Request Object containing SharePoint App Token</param> /// <param name="client">Client object containing Client data</param> /// <param name="matter">Matter object containing Matter data</param> /// <param name="subAreaOfLawList">String contains all sub area of law</param> /// <param name="mailListURL">URL contains list of mail recipients</param> /// <returns>Result of operation: Matter Shared successfully or not</returns> internal GenericResponseVM ShareMatterUtility(Client client, Matter matter, MatterDetails matterDetails, string mailSiteURL, string centralMailListURL, string matterLandingFlag, MatterConfigurations matterConfigurations) { bool shareFlag = false; string mailListName = centralMailListURL.Substring(centralMailListURL.LastIndexOf(ServiceConstants.FORWARD_SLASH, StringComparison.OrdinalIgnoreCase) + 1); string matterLocation = string.Concat(client.Url, ServiceConstants.FORWARD_SLASH, matter.Name); string ProvisionMatterValidation = string.Empty; GenericResponseVM genericResponse = null; if (!string.IsNullOrWhiteSpace(mailSiteURL)) { using (ClientContext clientContext = spoAuthorization.GetClientContext(mailSiteURL)) { genericResponse = validationFunctions.MatterDetailsValidation(matter, client, int.Parse(ServiceConstants.ProvisionMatterShareMatter, CultureInfo.InvariantCulture), matterConfigurations); if (genericResponse != null) { return genericResponse; } MatterInformationVM matterInformation = new MatterInformationVM() { Client = client, Matter = matter, MatterDetails = matterDetails }; // Get the current logged in User clientContext.Load(clientContext.Web.CurrentUser); clientContext.ExecuteQuery(); matterInformation.MatterCreator = clientContext.Web.CurrentUser.Title; if (ServiceConstants.TRUE == matterLandingFlag) { matterLocation = string.Concat(client.Url, ServiceConstants.FORWARD_SLASH, matterSettings.MatterLandingPageRepositoryName.Replace(ServiceConstants.SPACE, string.Empty), ServiceConstants.FORWARD_SLASH, matter.MatterGuid, ServiceConstants.ASPX_EXTENSION); matterInformation.MatterLocation = matterLocation; } // Step 4: Create Conflict check Information based on the conflict check flag and create mail body if (matterConfigurations.IsConflictCheck) { matterInformation.IsConflictCheck = true; } else { matterInformation.IsConflictCheck = false; } //List<FieldUserValue> userList = new List<FieldUserValue>(); //List<FieldUserValue> userEmailList = GenerateMailList(matter, new Client { Url = mailSiteURL }, ref userList); /////// Add the Matter URL in list //FieldUrlValue matterPath = new FieldUrlValue() //{ // Url = string.Concat(client.Url.Replace(String.Concat(ServiceConstants.HTTPS, ServiceConstants.COLON, // ServiceConstants.FORWARD_SLASH, ServiceConstants.FORWARD_SLASH), String.Concat(ServiceConstants.HTTP, ServiceConstants.COLON, // ServiceConstants.FORWARD_SLASH, ServiceConstants.FORWARD_SLASH)), ServiceConstants.FORWARD_SLASH, matter.Name, // ServiceConstants.FORWARD_SLASH, matter.Name), // Description = matter.Name //}; //matterInformation.MatterUrlPath = matterPath.Url; SerializeMatterToTableStorage(matterInformation); } } return genericResponse; }
/// <summary> /// Validates meta-data of a matter and returns the validation status (success/failure). /// </summary> /// <param name="matter">Matter object containing Matter data</param> /// <param name="clientContext">Client context object for SharePoint</param> /// <param name="methodNumber">Number indicating which method needs to be validated</param> /// <returns>A string value indicating whether validations passed or fail</returns> internal GenericResponseVM MatterMetadataValidation(Matter matter, Client client, int methodNumber, MatterConfigurations matterConfigurations) { GenericResponseVM genericResponseVM = null; genericResponseVM = MatterNameValidation(matter); if (genericResponseVM!=null) { return genericResponseVM; } if (int.Parse(ServiceConstants.ProvisionMatterCreateMatter, CultureInfo.InvariantCulture) == methodNumber || int.Parse(ServiceConstants.ProvisionMatterAssignContentType, CultureInfo.InvariantCulture) == methodNumber || int.Parse(ServiceConstants.ProvisionMatterUpdateMetadataForList, CultureInfo.InvariantCulture) == methodNumber) { if (string.IsNullOrWhiteSpace(matter.Id)) { return GenericResponse(errorSettings.IncorrectInputMatterIdCode, errorSettings.IncorrectInputMatterIdMessage); } else { var matterId = Regex.Match(matter.Id, matterSettings.SpecialCharacterExpressionMatterId, RegexOptions.IgnoreCase); if (int.Parse(matterSettings.MatterIdLength, CultureInfo.InvariantCulture) < matter.Id.Length || !matterId.Success) { return GenericResponse(errorSettings.IncorrectInputMatterIdCode, errorSettings.IncorrectInputMatterIdMessage); } } } if (int.Parse(ServiceConstants.ProvisionMatterCreateMatter, CultureInfo.InvariantCulture) == methodNumber || int.Parse(ServiceConstants.ProvisionMatterShareMatter, CultureInfo.InvariantCulture) == methodNumber || int.Parse(ServiceConstants.ProvisionMatterMatterLandingPage, CultureInfo.InvariantCulture) == methodNumber) { genericResponseVM = MatterDetailsValidation(matter, client, methodNumber, matterConfigurations); if (genericResponseVM!=null) { return genericResponseVM; } } try { if (!(int.Parse(ServiceConstants.ProvisionMatterCheckMatterExists, CultureInfo.InvariantCulture) == methodNumber) && !(int.Parse(ServiceConstants.ProvisionMatterAssignContentType, CultureInfo.InvariantCulture) == methodNumber)) { if (0 >= matter.AssignUserNames.Count()) { return GenericResponse(errorSettings.IncorrectInputUserNamesCode, errorSettings.IncorrectInputUserNamesMessage); } else { IList<string> userList = matter.AssignUserNames.SelectMany(x => x).Distinct().ToList(); //ToDo: Need to know the use of this method matterRespository.ResolveUserNames(client, userList).FirstOrDefault(); } } } catch (Exception) { return GenericResponse(errorSettings.IncorrectInputUserNamesCode, errorSettings.IncorrectInputUserNamesMessage); } if (int.Parse(ServiceConstants.ProvisionMatterAssignUserPermissions, CultureInfo.InvariantCulture) == methodNumber || int.Parse(ServiceConstants.ProvisionMatterMatterLandingPage, CultureInfo.InvariantCulture) == methodNumber || int.Parse(ServiceConstants.EditMatterPermission, CultureInfo.InvariantCulture) == methodNumber) { GenericResponseVM genericResponse = CheckUserPermission(matter); if (genericResponse!=null) { return genericResponse; } } if (int.Parse(ServiceConstants.ProvisionMatterAssignContentType, CultureInfo.InvariantCulture) == methodNumber || int.Parse(ServiceConstants.ProvisionMatterShareMatter, CultureInfo.InvariantCulture) == methodNumber) { GenericResponseVM genericResponse = ValidateContentType(matter); if (genericResponse!=null) { return genericResponse; } } return genericResponseVM; }
/// <summary> /// Assign or Remove Full Control base on parameter given. /// </summary> /// <param name="clientContext">Client context object</param> /// <param name="matter">Matter object</param> /// <param name="loggedInUser">Name of logged in user</param> /// <param name="listExists">List of existed list</param> /// <param name="listItemId">ID of the list</param> /// <param name="assignFullControl">Flag to determine Assign or Remove Permission</param> public void AssignRemoveFullControl(ClientContext clientContext, Matter matter, string loggedInUser, int listItemId, List<string> listExists, bool assignFullControl, bool hasFullPermission) { IList<IList<string>> currentUser = new List<IList<string>>(); IList<string> currentLoggedInUser = new List<string>() { loggedInUser }; currentUser.Add(currentLoggedInUser); IList<string> permission = new List<string>() { "Full Control" }; if (assignFullControl) { //Assign full control to Matter if (listExists.Contains(matter.Name)) { SPList.SetPermission(clientContext, currentUser, permission, matter.Name); } //Assign full control to OneNote if (listExists.Contains(matter.Name + "_OneNote")) { SPList.SetPermission(clientContext, currentUser, permission, matter.Name + "_OneNote"); } // Assign full control to Task list if (listExists.Contains(matter.Name + "_Task")) { SPList.SetPermission(clientContext, currentUser, permission, matter.Name + "_Task"); } //Assign full control to calendar if (listExists.Contains(matter.Name + "_Calendar")) { SPList.SetPermission(clientContext, currentUser, permission, matter.Name + "_Calendar"); } // Assign full control to Matter Landing page if (0 <= listItemId) { SPList.SetItemPermission(clientContext, currentUser, "Site Pages", listItemId, permission); } } else { if (!hasFullPermission) { //Remove full control to Matter if (listExists.Contains(matter.Name)) { RemoveFullControl(clientContext, matter.Name, loggedInUser, false, -1); } //Remove full control to OneNote if (listExists.Contains(matter.Name + "_OneNote")) { RemoveFullControl(clientContext, matter.Name + "_OneNote", loggedInUser, false, -1); } // Remove full control to Task list if (listExists.Contains(matter.Name + "_Task")) { RemoveFullControl(clientContext, matter.Name + "_Task", loggedInUser, false, -1); } //Remove full control to calendar if (listExists.Contains(matter.Name + "_Calendar")) { RemoveFullControl(clientContext, matter.Name + "_Calendar", loggedInUser, false, -1); } if (0 <= listItemId) { RemoveFullControl(clientContext, "Site Pages", loggedInUser, true, listItemId); } } } }
/// <summary> /// Validates details of a matter and returns the validation status. /// </summary> /// <param name="matter">Matter object containing Matter data</param> /// <param name="clientContext">Client context object for SharePoint</param> /// <param name="methodNumber">Number indicating which method needs to be validated</param> /// <returns>A string value indicating whether validations passed or fail</returns> internal GenericResponseVM MatterDetailsValidation(Matter matter, Client client, int methodNumber, MatterConfigurations matterConfigurations) { GenericResponseVM genericResponseVM = null; if (matterConfigurations.IsMatterDescriptionMandatory) { if (string.IsNullOrWhiteSpace(matter.Description)) { return GenericResponse(errorSettings.IncorrectInputMatterDescriptionCode, errorSettings.IncorrectInputMatterDescriptionMessage); } else { var matterDescription = Regex.Match(matter.Description, matterSettings.SpecialCharacterExpressionMatterDescription, RegexOptions.IgnoreCase); if (int.Parse(matterSettings.MatterDescriptionLength, CultureInfo.InvariantCulture) < matter.Description.Length || !matterDescription.Success) { return GenericResponse(errorSettings.IncorrectInputMatterDescriptionCode, errorSettings.IncorrectInputMatterDescriptionMessage); } } } if (matterConfigurations.IsConflictCheck) { DateTime conflictCheckedOnDate; bool isValidDate = DateTime.TryParse(matter.Conflict.CheckOn, out conflictCheckedOnDate); if (!isValidDate || 0 > DateTime.Compare(DateTime.Now, conflictCheckedOnDate)) { return GenericResponse(errorSettings.IncorrectInputConflictDateCode, errorSettings.IncorrectInputConflictDateMessage); } if (string.IsNullOrWhiteSpace(matter.Conflict.Identified)) { return GenericResponse(errorSettings.IncorrectInputConflictIdentifiedCode, errorSettings.IncorrectInputConflictIdentifiedMessage); } else { try { if (0 > string.Compare(ServiceConstants.FALSE, matter.Conflict.Identified, StringComparison.OrdinalIgnoreCase)) { if (0 >= matter.BlockUserNames.Count()) { return GenericResponse(errorSettings.IncorrectInputBlockUserNamesCode, errorSettings.IncorrectInputBlockUserNamesMessage); } else { //ToDo: Need to understand the need of this method matterRespository.ResolveUserNames(client, matter.BlockUserNames).FirstOrDefault(); } } } catch (Exception) { return GenericResponse(errorSettings.IncorrectInputBlockUserNamesCode, errorSettings.IncorrectInputBlockUserNamesMessage); } } if (string.IsNullOrWhiteSpace(matter.Conflict.CheckBy)) { return GenericResponse(errorSettings.IncorrectInputConflictCheckByCode, errorSettings.IncorrectInputConflictCheckByMessage); } else { try { //ToDo: Need to understand the need of this method matterRespository.ResolveUserNames(client, new List<string>() { matter.Conflict.CheckBy }).FirstOrDefault(); } catch (Exception) { return GenericResponse(errorSettings.IncorrectInputConflictCheckByCode, errorSettings.IncorrectInputConflictCheckByMessage); } } } if (int.Parse(ServiceConstants.ProvisionMatterCreateMatter, CultureInfo.InvariantCulture) == methodNumber && 0 >= matter.Roles.Count()) { return GenericResponse(errorSettings.IncorrectInputUserRolesCode, errorSettings.IncorrectInputUserRolesMessage); } return genericResponseVM; }
/// <summary> /// Remove old users and assign permissions to new users. /// </summary> /// <param name="clientContext">ClientContext object</param> /// <param name="requestObject">RequestObject</param> /// <param name="client">Client object</param> /// <param name="matter">Matter object</param> /// <param name="users">List of users to remove</param> /// <param name="isListItem">ListItem or list</param> /// <param name="list">List object</param> /// <param name="matterLandingPageId">List item id</param> /// <param name="isEditMode">Add/ Edit mode</param> /// <returns></returns> public static bool UpdatePermission(ClientContext clientContext, Matter matter, List<string> users, string loggedInUserTitle, bool isListItem, string listName, int matterLandingPageId, bool isEditMode) { bool result = false; try { if (null != clientContext && !string.IsNullOrWhiteSpace(listName)) { if (isEditMode) { SPList.RemoveSpecificUsers(clientContext, users, loggedInUserTitle, isListItem, listName, matterLandingPageId); } // Add permission if (!isListItem) { result = SPList.SetPermission(clientContext, matter.AssignUserNames, matter.Permissions, listName); } else { result = SPList.SetItemPermission(clientContext, matter.AssignUserNames, "Site Pages", matterLandingPageId, matter.Permissions); } } } catch (Exception) { throw; } // To avoid the invalid symbol error while parsing the JSON, return the response in lower case return result; }
/// <summary> /// Validates content type for the matter. /// </summary> /// <param name="matter">Matter object containing Matter data</param> /// <returns>A string value indicating whether validations passed or fail</returns> private GenericResponseVM ValidateContentType(Matter matter) { if ((0 >= matter.ContentTypes.Count()) || string.IsNullOrWhiteSpace(matter.DefaultContentType)) { return GenericResponse(errorSettings.IncorrectInputContentTypeCode, errorSettings.IncorrectInputContentTypeMessage); } else { foreach (string contentType in matter.ContentTypes) { var contentTypeCheck = Regex.Match(contentType, matterSettings.SpecialCharacterExpressionContentType, RegexOptions.IgnoreCase); if (contentTypeCheck.Success || int.Parse(matterSettings.ContentTypeLength, CultureInfo.InvariantCulture) < contentType.Length) { return GenericResponse(errorSettings.IncorrectInputContentTypeCode, errorSettings.IncorrectInputContentTypeMessage); } } var defaultContentTypeCheck = Regex.Match(matter.DefaultContentType, matterSettings.SpecialCharacterExpressionContentType, RegexOptions.IgnoreCase); if (defaultContentTypeCheck.Success || int.Parse(matterSettings.ContentTypeLength, CultureInfo.InvariantCulture) < matter.DefaultContentType.Length) { return GenericResponse(errorSettings.IncorrectInputContentTypeCode, errorSettings.IncorrectInputContentTypeMessage); } } return null; }
/// <summary> /// Sets the default content type based on user selection for the new matter that is getting created /// </summary> /// <param name="clientContext">SP client context</param> /// <param name="list">Name of the list</param> /// <param name="requestObject">Request Object</param> /// <param name="client">Client Object</param> /// <param name="matter">Matter Object</param> private void SetDefaultContentType(ClientContext clientContext, List list, Client client, Matter matter) { int contentCount = 0, contentSwap = 0; try { ContentTypeCollection currentContentTypeOrder = list.ContentTypes; clientContext.Load(currentContentTypeOrder); clientContext.ExecuteQuery(); IList<ContentTypeId> updatedContentTypeOrder = new List<ContentTypeId>(); foreach (ContentType contentType in currentContentTypeOrder) { if (0 == string.Compare(contentType.Name, matter.DefaultContentType, StringComparison.OrdinalIgnoreCase)) { contentSwap = contentCount; } if (0 != string.Compare(contentType.Name, contentTypesConfig.HiddenContentType, StringComparison.OrdinalIgnoreCase)) { updatedContentTypeOrder.Add(contentType.Id); contentCount++; } } if (updatedContentTypeOrder.Count > contentSwap) { ContentTypeId documentContentType = updatedContentTypeOrder[0]; updatedContentTypeOrder[0] = updatedContentTypeOrder[contentSwap]; updatedContentTypeOrder.RemoveAt(contentSwap); updatedContentTypeOrder.Add(documentContentType); } list.RootFolder.UniqueContentTypeOrder = updatedContentTypeOrder; list.RootFolder.Update(); list.Update(); clientContext.ExecuteQuery(); } catch (Exception exception) { customLogger.LogError(exception, MethodBase.GetCurrentMethod().DeclaringType.Name, MethodBase.GetCurrentMethod().Name, logTables.SPOLogTable); throw; } }
/// <summary> /// Configures XML code of List View web part. /// </summary> /// <param name="requestObject">Request Object</param> /// <param name="sitePageLib">SharePoint List of matter library</param> /// <param name="clientContext">SharePoint Client Context</param> /// <param name="objFileInfo">Object of FileCreationInformation</param> /// <param name="client">Client object containing Client data</param> /// <param name="matter">Matter object containing Matter data</param> /// <param name="titleUrl">Segment of URL</param> /// <returns>Configured ListView Web Part</returns> internal string ConfigureListViewWebPart(List sitePageLib, ClientContext clientContext, string pageName, Client client, Matter matter, string titleUrl) { string viewName = string.Empty; string result = string.Empty; try { Uri uri = new Uri(client.Url); ViewCollection viewColl = sitePageLib.Views; clientContext.Load( viewColl, views => views.Include( view => view.Title, view => view.Id)); clientContext.ExecuteQuery(); foreach (View view in viewColl) { viewName = Convert.ToString(view.Id, CultureInfo.InvariantCulture); break; } viewName = string.Concat(ServiceConstants.OPENING_CURLY_BRACE, viewName, ServiceConstants.CLOSING_CURLY_BRACE); string listViewWebPart = ServiceConstants.LIST_VIEW_WEBPART; listViewWebPart = string.Format(CultureInfo.InvariantCulture, listViewWebPart, Convert.ToString(sitePageLib.Id, CultureInfo.InvariantCulture), titleUrl, string.Concat(ServiceConstants.OPENING_CURLY_BRACE, Convert.ToString(sitePageLib.Id, CultureInfo.InvariantCulture), ServiceConstants.CLOSING_CURLY_BRACE), viewName, string.Concat(uri.AbsolutePath, ServiceConstants.FORWARD_SLASH, matter.Name, ServiceConstants.FORWARD_SLASH, pageName)); result = listViewWebPart; } catch (Exception exception) { customLogger.LogError(exception, MethodBase.GetCurrentMethod().DeclaringType.Name, MethodBase.GetCurrentMethod().Name, logTables.SPOLogTable); throw; } return result; }
/// <summary> /// Function to share the matter. /// </summary> /// <param name="requestObject">Request Object containing SharePoint App Token</param> /// <param name="client">Client object containing Client data</param> /// <param name="matter">Matter object containing Matter data</param> /// <param name="subAreaOfLawList">String contains all sub area of law</param> /// <param name="mailListURL">URL contains list of mail recipients</param> /// <returns>Result of operation: Matter Shared successfully or not</returns> internal GenericResponseVM ShareMatterUtility(Client client, Matter matter, MatterDetails matterDetails, string mailSiteURL, string centralMailListURL, string matterLandingFlag, MatterConfigurations matterConfigurations) { bool shareFlag = false; string mailListName = centralMailListURL.Substring(centralMailListURL.LastIndexOf(ServiceConstants.FORWARD_SLASH, StringComparison.OrdinalIgnoreCase) + 1); string matterLocation = string.Concat(client.Url, ServiceConstants.FORWARD_SLASH, matter.Name); string ProvisionMatterValidation = string.Empty; GenericResponseVM genericResponse = null; if (!string.IsNullOrWhiteSpace(mailSiteURL)) { using (ClientContext clientContext = spoAuthorization.GetClientContext(mailSiteURL)) { genericResponse = validationFunctions.MatterDetailsValidation(matter, client, int.Parse(ServiceConstants.ProvisionMatterShareMatter, CultureInfo.InvariantCulture), matterConfigurations); if(genericResponse!=null) { return genericResponse; } // Get the current logged in User clientContext.Load(clientContext.Web.CurrentUser); clientContext.ExecuteQuery(); string matterMailBody, blockUserNames; // Generate Mail Subject string matterMailSubject = string.Format(CultureInfo.InvariantCulture, mailSettings.MatterMailSubject, matter.Id, matter.Name, clientContext.Web.CurrentUser.Title); // Logic to Create Mail body // Step 1: Create Matter Information // Step 2: Create Team Information // Step 3: Create Access Information // Step 4: Create Conflict check Information based on the conflict check flag and create mail body // Step 1: Create Matter Information string defaultContentType = string.Format(CultureInfo.InvariantCulture, mailSettings.MatterMailDefaultContentTypeHtmlChunk, matter.DefaultContentType); string matterType = string.Join(";", matter.ContentTypes.ToArray()).TrimEnd(';').Replace(matter.DefaultContentType, defaultContentType); // Step 2: Create Team Information string secureMatter = ServiceConstants.FALSE.ToUpperInvariant() == matter.Conflict.SecureMatter.ToUpperInvariant() ? ServiceConstants.NO : ServiceConstants.YES; string mailBodyTeamInformation = string.Empty; mailBodyTeamInformation = TeamMembersPermissionInformation(matterDetails, mailBodyTeamInformation); // Step 3: Create Access Information if (ServiceConstants.TRUE == matterLandingFlag) { matterLocation = string.Concat(client.Url, ServiceConstants.FORWARD_SLASH, matterSettings.MatterLandingPageRepositoryName.Replace(ServiceConstants.SPACE, string.Empty), ServiceConstants.FORWARD_SLASH, matter.MatterGuid, ServiceConstants.ASPX_EXTENSION); } string oneNotePath = string.Concat(client.Url, ServiceConstants.FORWARD_SLASH, matter.MatterGuid, matterSettings.OneNoteLibrarySuffix, ServiceConstants.FORWARD_SLASH, matter.MatterGuid, ServiceConstants.FORWARD_SLASH, matter.MatterGuid); // Step 4: Create Conflict check Information based on the conflict check flag and create mail body if (matterConfigurations.IsConflictCheck) { string conflictIdentified = ServiceConstants.FALSE.ToUpperInvariant() == matter.Conflict.Identified.ToUpperInvariant() ? ServiceConstants.NO : ServiceConstants.YES; blockUserNames = string.Join(";", matter.BlockUserNames.ToArray()).Trim().TrimEnd(';'); blockUserNames = !String.IsNullOrEmpty(blockUserNames) ? string.Format(CultureInfo.InvariantCulture, "<div>{0}: {1}</div>", "Conflicted User", blockUserNames) : string.Empty; matterMailBody = string.Format(CultureInfo.InvariantCulture, mailSettings.MatterMailBodyMatterInformation, client.Name, client.Id, matter.Name, matter.Id, matter.Description, matterType) + string.Format(CultureInfo.InvariantCulture, mailSettings.MatterMailBodyConflictCheck, ServiceConstants.YES, matter.Conflict.CheckBy, Convert.ToDateTime(matter.Conflict.CheckOn, CultureInfo.InvariantCulture).ToString(matterSettings.MatterCenterDateFormat, CultureInfo.InvariantCulture), conflictIdentified) + string.Format(CultureInfo.InvariantCulture, mailSettings.MatterMailBodyTeamMembers, secureMatter, mailBodyTeamInformation, blockUserNames, client.Url, oneNotePath, matter.Name, matterLocation, matter.Name); } else { blockUserNames = string.Empty; matterMailBody = string.Format(CultureInfo.InvariantCulture, mailSettings.MatterMailBodyMatterInformation, client.Name, client.Id, matter.Name, matter.Id, matter.Description, matterType) + string.Format(CultureInfo.InvariantCulture, mailSettings.MatterMailBodyTeamMembers, secureMatter, mailBodyTeamInformation, blockUserNames, client.Url, oneNotePath, matter.Name, matterLocation, matter.Name); } Web web = clientContext.Web; List mailList = web.Lists.GetByTitle(mailListName); List<FieldUserValue> userList = new List<FieldUserValue>(); List<FieldUserValue> userEmailList = GenerateMailList(matter, new Client {Url = mailSiteURL }, ref userList); ///// Add the Matter URL in list FieldUrlValue matterPath = new FieldUrlValue() { Url = string.Concat(client.Url.Replace(String.Concat(ServiceConstants.HTTPS, ServiceConstants.COLON, ServiceConstants.FORWARD_SLASH, ServiceConstants.FORWARD_SLASH), String.Concat(ServiceConstants.HTTP, ServiceConstants.COLON, ServiceConstants.FORWARD_SLASH, ServiceConstants.FORWARD_SLASH)), ServiceConstants.FORWARD_SLASH, matter.Name, ServiceConstants.FORWARD_SLASH, matter.Name), Description = matter.Name }; List<string> columnNames = new List<string>() { matterSettings.ShareListColumnMatterPath, matterSettings.ShareListColumnMailList, mailSettings.ShareListColumnMailBody, mailSettings.ShareListColumnMailSubject }; List<object> columnValues = new List<object>() { matterPath, userEmailList, matterMailBody, matterMailSubject }; // To avoid the invalid symbol error while parsing the JSON, return the response in lower case matterRepositoy.AddItem(clientContext, mailList, columnNames, columnValues); } } return genericResponse; }