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;
}
