/// <summary> /// This method will store external requests information in Azure Table Storage /// </summary> /// <param name="externalSharingRequest"></param> /// <returns></returns> private void SaveExternalSharingRequest(MatterInformationVM matterInformation) { try { CloudStorageAccount cloudStorageAccount = CloudStorageAccount.Parse(generalSettings.CloudStorageConnectionString); CloudTableClient tableClient = cloudStorageAccount.CreateCloudTableClient(); tableClient.DefaultRequestOptions = new TableRequestOptions { PayloadFormat = TablePayloadFormat.JsonNoMetadata }; // Retrieve a reference to the table. CloudTable table = tableClient.GetTableReference(logTables.ExternalAccessRequests); // Create the table if it doesn't exist. table.CreateIfNotExists(); //Insert the entity into Table Storage matterInformation.PartitionKey = matterInformation.Matter.Name; matterInformation.RowKey = $"{Guid.NewGuid().ToString()}${matterInformation.Matter.Id}"; matterInformation.Status = "Pending"; matterInformation.MatterUpdateStatus = "Pending"; string matterInformationObject = Newtonsoft.Json.JsonConvert.SerializeObject(matterInformation); matterInformation.SerializeMatter = matterInformationObject; TableOperation insertOperation = TableOperation.Insert(matterInformation); table.Execute(insertOperation); } catch (Exception ex) { throw; } }
/// <summary> /// Update the status in Azure Table Storage for the corresponding Parition and Row Key /// for which the user has accepted the invitation /// </summary> /// <param name="externalSharingRequest"></param> public static void UpdateTableStorageEntity(MatterInformationVM matterInformation, TextWriter log, string connection, string tableName, string status, string statusColumnName) { try { CloudStorageAccount cloudStorageAccount = CloudStorageAccount.Parse(connection); CloudTableClient tableClient = cloudStorageAccount.CreateCloudTableClient(); // Create the CloudTable object that represents the "people" table. CloudTable table = tableClient.GetTableReference(tableName); // Create a retrieve operation that takes a entity. TableOperation retrieveOperation = TableOperation.Retrieve<MatterInformationVM>(matterInformation.PartitionKey, matterInformation.RowKey); // Execute the operation. TableResult retrievedResult = table.Execute(retrieveOperation); // Assign the result to a ExternalSharingRequest object. MatterInformationVM updateEntity = (MatterInformationVM)retrievedResult.Result; if (updateEntity != null) { if(statusColumnName=="Status") { updateEntity.Status = status; } if (statusColumnName == "MatterUpdateStatus") { updateEntity.MatterUpdateStatus = status; } TableOperation updateOperation = TableOperation.Replace(updateEntity); table.Execute(updateOperation); log.WriteLine($"Updated the matter status to Accepted in Azure Table Storage"); } } catch (Exception ex) { log.WriteLine($"Exception occured in the method UpdateTableStorageEntity. {ex}"); } }
/// <summary> /// This method will store the external sharing request in a list called "MatterCenterExternalRequests" /// and send notification to the external user regarding the information that is getting shared /// </summary> /// <param name="externalSharingRequest"></param> /// <returns></returns> public GenericResponseVM ShareMatter(MatterInformationVM matterInformation) { var tempMatterInformation = matterInformation; int index = 0; foreach (var assignUserEmails in matterInformation.Matter.AssignUserEmails) { foreach (string email in assignUserEmails) { //First check whether the user exists in SharePoint or not if (!string.IsNullOrWhiteSpace(email) && userDetails.CheckUserPresentInMatterCenter(generalSettings.SiteURL, email) == false) { //If not, store external request in a list SaveExternalSharingRequest(matterInformation); //Send notification to the user with appropriate information SendExternalNotification(matterInformation, matterInformation.Matter.Permissions[index], matterInformation.Matter.AssignUserEmails[index][0]); } } index = index + 1; } return null; }
public async void Send_ExternalSharing_Notification() { var assignUserEmails = new List<IList<string>>(); var userEmails = new List<string>(); userEmails.Add("*****@*****.**"); assignUserEmails.Add(userEmails); userEmails = new List<string>(); userEmails.Add("*****@*****.**"); assignUserEmails.Add(userEmails); var assignUserNames = new List<IList<string>>(); var userNames = new List<string>(); userNames.Add("Wilson Gajarla"); userNames.Add(""); assignUserNames.Add(userNames); userNames = new List<string>(); userNames.Add("*****@*****.**"); userNames.Add(""); assignUserNames.Add(userNames); var permissions = new List<string>(); permissions.Add("Full Control"); permissions.Add("Full Control"); var roles = new List<string>(); roles.Add("Responsible Attorney"); roles.Add("Legal Admin"); var uploadBlockedUsers = new List<string>(); uploadBlockedUsers.Add("*****@*****.**"); var matterMetaInformation = new MatterInformationVM() { Client = new Client { Url = "https://msmatter.sharepoint.com/sites/microsoft", Id = "100001", Name = "Microsoft" }, Matter = new Matter { Id= "351085190a4ce42e2871e748b4e5d8ce", Name = "vTest4", BlockUserNames = new List<string>() { "*****@*****.**" }, AssignUserNames = assignUserNames, AssignUserEmails = assignUserEmails, Permissions = permissions, Roles = roles, Conflict = new Conflict() { Identified = "True" } }, MatterDetails = new MatterDetails { ResponsibleAttorney = "Wilson Gajarla;", ResponsibleAttorneyEmail = "Wilson Gajarla;", UploadBlockedUsers = uploadBlockedUsers, TeamMembers = "Wilson Gajarla;[email protected]", RoleInformation = "{\"Responsible Attorney\":\"Wilson Gajarla\",\"Legal Admin\":\"[email protected]\"}" }, EditMode = true }; using (var client = testServer.CreateClient().AcceptJson()) { var response = await client.PostAsJsonAsync("http://localhost:44323/api/v1/matter/sharematter", matterMetaInformation); var result = response.Content.ReadAsJsonAsync<GenericResponseVM>().Result; Assert.NotNull(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; } 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> /// This method will send notifications to external users /// </summary> /// <param name="externalSharingRequest"></param> /// <returns></returns> private GenericResponseVM SendExternalNotification(MatterInformationVM matterInformation, string permission, string externalEmail) { var clientUrl = $"{matterInformation.Client.Url}"; try { string roleId = ""; switch (permission.ToLower()) { case "full control": roleId = ((int)SPORoleIdMapping.FullControl).ToString(); break; case "contribute": roleId = ((int)SPORoleIdMapping.Contribute).ToString(); break; case "read": roleId = ((int)SPORoleIdMapping.Read).ToString(); break; } PeoplePickerUser peoplePickerUser = new PeoplePickerUser(); peoplePickerUser.Key = externalEmail; peoplePickerUser.Description = externalEmail; peoplePickerUser.DisplayText = externalEmail; peoplePickerUser.EntityType = ""; peoplePickerUser.ProviderDisplayName = ""; peoplePickerUser.ProviderName = ""; peoplePickerUser.IsResolved = true; EntityData entityData = new EntityData(); entityData.SPUserID = externalEmail; entityData.Email = externalEmail; entityData.IsBlocked = "False"; entityData.PrincipalType = "UNVALIDATED_EMAIL_ADDRESS"; entityData.AccountName = externalEmail; entityData.SIPAddress = externalEmail; peoplePickerUser.EntityData = entityData; string peoplePicker = Newtonsoft.Json.JsonConvert.SerializeObject(peoplePickerUser); peoplePicker = $"[{peoplePicker}]"; string roleValue = $"role:{roleId}"; bool sendEmail = true; bool includeAnonymousLinkInEmail = false; bool propagateAcl = false; bool useSimplifiedRoles = true; string matterLandingPageUrl = $"{clientUrl}/sitepages/{matterInformation.Matter.MatterGuid + ServiceConstants.ASPX_EXTENSION}"; string url = matterLandingPageUrl; string emailBody = $"The following information has been shared with you {matterInformation.Matter.Name}"; string emailSubject = $"The following information has been shared with you {matterInformation.Matter.Name}"; #region Doc Sharing API SharingResult sharingResult = null; using (var clientContext = spoAuthorization.GetClientContext(clientUrl)) { sharingResult = Web.ShareObject(clientContext, url, peoplePicker, roleValue, 0, propagateAcl, sendEmail, includeAnonymousLinkInEmail, emailSubject, emailBody, useSimplifiedRoles); clientContext.Load(sharingResult); clientContext.ExecuteQuery(); } return null; #endregion } catch (Exception ex) { throw; } }
public IActionResult CheckMatterExists([FromBody]MatterMetdataVM matterMetadataVM) { GenericResponseVM genericResponse = ServiceUtility.GenericResponse(matterSettings.DeleteMatterCode, ServiceConstants.TRUE); var client = matterMetadataVM.Client; var matter = matterMetadataVM.Matter; var matterConfiguration = matterMetadataVM.MatterConfigurations; if (null == client && null == matter && string.IsNullOrWhiteSpace(client.Url)) { genericResponse = new GenericResponseVM() { Value = errorSettings.MessageNoInputs, Code = HttpStatusCode.BadRequest.ToString(), Description = "No input data is passed", IsError = true }; return matterCenterServiceFunctions.ServiceResponse(genericResponse, (int)HttpStatusCode.BadRequest); } var matterInformation = new MatterInformationVM() { Client = client, Matter = matter }; genericResponse = validationFunctions.IsMatterValid(matterInformation, int.Parse(ServiceConstants.PROVISION_MATTER_CHECK_MATTER_EXISTS, CultureInfo.InvariantCulture), null); if(genericResponse!=null) { genericResponse.Description = "Validation failed"; genericResponse.IsError = true; return matterCenterServiceFunctions.ServiceResponse(genericResponse, (int)HttpStatusCode.BadRequest); } try { if (!matterMetadataVM.HasErrorOccurred) { genericResponse = matterProvision.CheckMatterExists(matterMetadataVM); if (genericResponse != null) { genericResponse.Description = genericResponse.Value; genericResponse.IsError = true; return matterCenterServiceFunctions.ServiceResponse(genericResponse, (int)HttpStatusCode.OK); } else { genericResponse = ServiceUtility.GenericResponse(ServiceConstants.SUCCESS, ServiceConstants.TRUE); return matterCenterServiceFunctions.ServiceResponse(genericResponse, (int)HttpStatusCode.OK); } } else { genericResponse = matterProvision.DeleteMatter(matterMetadataVM as MatterVM); genericResponse.IsError = true; genericResponse.Description = $"Error occured when checking whether the given {errorSettings.Item} exisits or not"; return matterCenterServiceFunctions.ServiceResponse(genericResponse, (int)HttpStatusCode.BadRequest); } } catch (Exception exception) { genericResponse = matterProvision.DeleteMatter(matterMetadataVM as MatterVM); customLogger.LogError(exception, MethodBase.GetCurrentMethod().DeclaringType.Name, MethodBase.GetCurrentMethod().Name, logTables.SPOLogTable); var errResponse = customLogger.GenerateErrorResponse(exception); return matterCenterServiceFunctions.ServiceResponse(errResponse, (int)HttpStatusCode.InternalServerError); } }
public void UpdateUserPermissionsForMatter(MatterInformationVM matterInformation, IConfigurationRoot configuration, System.Security.SecureString securePassword) { var matter = matterInformation.Matter; var matterDetails = matterInformation.MatterDetails; var client = matterInformation.Client; int listItemId = -1; string loggedInUserName = ""; bool isEditMode = matterInformation.EditMode; ClientContext clientContext = null; IEnumerable<RoleAssignment> userPermissionOnLibrary = null; //GenericResponseVM genericResponse = null; try { clientContext = new ClientContext(matterInformation.Client.Url); clientContext.Credentials = new SharePointOnlineCredentials(configuration["General:AdminUserName"], securePassword); //if (null != matter.Conflict && !string.IsNullOrWhiteSpace(matter.Conflict.Identified)) //{ // if (Convert.ToBoolean(matter.Conflict.Identified, System.Globalization.CultureInfo.InvariantCulture)) // { // genericResponse = CheckSecurityGroupInTeamMembers(clientContext, matter, matterInformation.UserIds); // } //} //else //{ // //genericResponse = string.Format(System.Globalization.CultureInfo.InvariantCulture, ConstantStrings.ServiceResponse, TextConstants.IncorrectInputConflictIdentifiedCode, TextConstants.IncorrectInputConflictIdentifiedMessage); // return; //} //if (genericResponse == null) //{ PropertyValues matterStampedProperties = SPList.GetListProperties(clientContext, matter.Name); loggedInUserName = SPList.GetLoggedInUserDetails(clientContext).Name; // Get matter library current permissions userPermissionOnLibrary = SPList.FetchUserPermissionForLibrary(clientContext, matter.Name); string originalMatterName = SPList.GetMatterName(clientContext, matter.Name); listItemId = SPList.RetrieveItemId(clientContext, "Site Pages", originalMatterName); List<string> usersToRemove = RetrieveMatterUsers(userPermissionOnLibrary); bool hasFullPermission = CheckFullPermissionInAssignList(matter.AssignUserNames, matter.Permissions, loggedInUserName); List<string> listExists = MatterAssociatedLists(clientContext, matter.Name); AssignRemoveFullControl(clientContext, matter, loggedInUserName, listItemId, listExists, true, hasFullPermission); bool result = false; if (listExists.Contains(matter.Name)) { result = UpdatePermission(clientContext, matter, usersToRemove, loggedInUserName, false, matter.Name, -1, isEditMode); } if (listExists.Contains(matter.Name + configuration["Matter:OneNoteLibrarySuffix"])) { result = UpdatePermission(clientContext, matter, usersToRemove, loggedInUserName, false, matter.Name + configuration["Matter:OneNoteLibrarySuffix"], -1, isEditMode); } if (listExists.Contains(matter.Name + configuration["Matter:CalendarNameSuffix"])) { result = UpdatePermission(clientContext, matter, usersToRemove, loggedInUserName, false, matter.Name + configuration["Matter:CalendarNameSuffix"], -1, isEditMode); } if (listExists.Contains(matter.Name + configuration["Matter:TaskNameSuffix"])) { result = UpdatePermission(clientContext, matter, usersToRemove, loggedInUserName, false, matter.Name + configuration["Matter:TaskNameSuffix"], -1, isEditMode); } if (0 <= listItemId) { result = UpdatePermission(clientContext, matter, usersToRemove, loggedInUserName, true, "Site Pages", listItemId, isEditMode); } // Update matter metadata result = UpdateMatterStampedProperties(clientContext, matterDetails, matter, matterStampedProperties, isEditMode, configuration); //} } catch (Exception ex) { MatterRevertList matterRevertListObject = new MatterRevertList() { MatterLibrary = matter.Name, MatterOneNoteLibrary = matter.Name + configuration["Matter:OneNoteLibrarySuffix"], MatterCalendar = matter.Name + configuration["Matter:CalendarNameSuffix"], MatterTask = matter.Name + configuration["Matter:TaskNameSuffix"], MatterSitePages = "Site Pages" }; RevertMatterUpdates(client, matter, clientContext, matterRevertListObject, loggedInUserName, userPermissionOnLibrary, listItemId, isEditMode); } //return ServiceUtility.GenericResponse("9999999", "Error in updating matter information"); }
public GenericResponseVM CreateMatter(MatterMetdataVM matterMetadataVM) { var client = matterMetadataVM.Client; var matter = matterMetadataVM.Matter; var matterConfiguration = matterMetadataVM.MatterConfigurations; GenericResponseVM genericResponseVM = null; try { using (ClientContext clientContext = spoAuthorization.GetClientContext(client.Url)) { if (!matterRepositoy.CheckPermissionOnList(clientContext, listNames.MatterConfigurationsList, PermissionKind.EditListItems)) { return ServiceUtility.GenericResponse(errorSettings.UserNotSiteOwnerCode, errorSettings.UserNotSiteOwnerMessage); } var matterInformation = new MatterInformationVM() { Client = client, Matter = matter }; genericResponseVM = validationFunctions.IsMatterValid(matterInformation, int.Parse(ServiceConstants.PROVISION_MATTER_CREATEMATTER), matterConfiguration); if (genericResponseVM != null) { return ServiceUtility.GenericResponse(genericResponseVM.Code, genericResponseVM.Value); } genericResponseVM = CheckMatterExists(matterMetadataVM); if (genericResponseVM != null) { return ServiceUtility.GenericResponse(genericResponseVM.Code, genericResponseVM.Value); } if (null != matter.Conflict && !string.IsNullOrWhiteSpace(matter.Conflict.Identified)) { if (Convert.ToBoolean(matter.Conflict.Identified, CultureInfo.InvariantCulture)) { genericResponseVM = editFunctions.CheckSecurityGroupInTeamMembers(client, matter, matterMetadataVM.UserIds); if (genericResponseVM != null) { return ServiceUtility.GenericResponse(errorSettings.IncorrectInputConflictIdentifiedCode, errorSettings.IncorrectInputConflictIdentifiedMessage); } } genericResponseVM = CreateMatter(clientContext, matterMetadataVM); } } return genericResponseVM; } catch (Exception ex) { throw; } }
public GenericResponseVM CheckSecurityGroupExists(MatterInformationVM matterInformationVM) { GenericResponseVM genericResponseVM = null; var matter = matterInformationVM.Matter; var client = matterInformationVM.Client; var userids = matterInformationVM.UserIds; using (ClientContext clientContext = spoAuthorization.GetClientContext(matterInformationVM.Client.Url)) { genericResponseVM = matterRepositoy.ValidateTeamMembers(clientContext, matter, userids); if (genericResponseVM != null) { return genericResponseVM; } else { if (null != matter.Conflict && !string.IsNullOrWhiteSpace(matter.Conflict.Identified)) { if (0 == matter.AssignUserEmails.Count()) { return ServiceUtility.GenericResponse(errorSettings.IncorrectInputUserNamesCode, errorSettings.IncorrectInputUserNamesMessage); } else { if (Convert.ToBoolean(matter.Conflict.Identified, CultureInfo.InvariantCulture)) { return editFunctions.CheckSecurityGroupInTeamMembers(client, matter, userids); } } } else { return ServiceUtility.GenericResponse(errorSettings.IncorrectInputConflictIdentifiedCode, errorSettings.IncorrectInputConflictIdentifiedMessage); } } } return genericResponseVM; }
public GenericResponseVM AssignUserPermissions(MatterMetdataVM matterMetadataVM) { var client = matterMetadataVM.Client; var matter = matterMetadataVM.Matter; var matterConfigurations = matterMetadataVM.MatterConfigurations; ClientContext clientContext = null; string calendarName = string.Concat(matter.Name, matterSettings.CalendarNameSuffix); string oneNoteLibraryName = string.Concat(matter.Name, matterSettings.OneNoteLibrarySuffix); string taskLibraryName = string.Concat(matter.Name, matterSettings.TaskNameSuffix); GenericResponseVM genericResponseVM = null; using (clientContext = spoAuthorization.GetClientContext(client.Url)) { MatterInformationVM matterInfo = new MatterInformationVM() { Client = matterMetadataVM.Client, Matter = matterMetadataVM.Matter, MatterDetails = matterMetadataVM.MatterDetails }; genericResponseVM = validationFunctions.IsMatterValid(matterInfo, int.Parse(ServiceConstants.PROVISION_MATTER_ASSIGN_USER_PERMISSIONS, CultureInfo.InvariantCulture), null); if (genericResponseVM != null) { DeleteMatter(matterMetadataVM as MatterVM); return genericResponseVM; } if (!string.IsNullOrWhiteSpace(matter.Name)) { //Assign permission for Matter library matterRepositoy.SetPermission(clientContext, matter.AssignUserEmails, matter.Permissions, matter.Name); //Assign permission for OneNote library matterRepositoy.SetPermission(clientContext, matter.AssignUserEmails, matter.Permissions, oneNoteLibraryName); if (matterSettings.IsCreateCalendarEnabled && matterConfigurations.IsCalendarSelected) { bool returnValueCalendar = matterRepositoy.SetPermission(clientContext, matter.AssignUserEmails, matter.Permissions, calendarName); if (!returnValueCalendar) { genericResponseVM = new GenericResponseVM() { Code = errorSettings.ErrorCodeCalendarCreation, Value = errorSettings.ErrorMessageCalendarCreation, IsError = true }; return genericResponseVM; } } // Assign permission to task list if it is selected if (matterConfigurations.IsTaskSelected) { bool returnValueTask = matterRepositoy.SetPermission(clientContext, matter.AssignUserEmails, matter.Permissions, taskLibraryName); if (!returnValueTask) { genericResponseVM = new GenericResponseVM() { Code = errorSettings.ErrorMessageTaskCreation, Value = errorSettings.ErrorCodeAddTaskList, IsError = true }; return genericResponseVM; } } } } return genericResponseVM; }
public GenericResponseVM UpdateMatterMetadata(MatterMetdataVM matterMetadata) { var matter = matterMetadata.Matter; var matterDetails = matterMetadata.MatterDetails; var client = matterMetadata.Client; ClientContext clientContext = null; GenericResponseVM genericResponse = null; try { MatterInformationVM matterInfo = new MatterInformationVM() { Client = matterMetadata.Client, Matter = matterMetadata.Matter, MatterDetails = matterMetadata.MatterDetails }; clientContext = spoAuthorization.GetClientContext(matterMetadata.Client.Url); PropertyValues matterStampedProperties = matterRepositoy.GetStampedProperties(clientContext, matter.Name); Dictionary<string, string> propertyList = SetStampProperty(matterMetadata); matterRepositoy.SetPropertBagValuesForList(clientContext, matterStampedProperties, matter.Name, propertyList); //As part of final step in matter creation, check whether any assigned users are external to the //organization and if yes, send notification to that user to accepct the invitation so that he can access matter center //Need to loop each matter information, update the table storage with that matter information, before sending //notification to external user if (matterInfo.Matter != null && matterInfo.Matter.Roles != null && matterInfo.Matter.Roles.Count > 0) { ShareMatterToExtUser(matterInfo); } genericResponse = ServiceUtility.GenericResponse("", "Matter Update Success"); } catch (Exception ex) { DeleteMatter(matterMetadata as MatterVM); customLogger.LogError(ex, MethodBase.GetCurrentMethod().DeclaringType.Name, MethodBase.GetCurrentMethod().Name, logTables.SPOLogTable); throw; } return genericResponse; }
public GenericResponseVM UpdateMatter(MatterInformationVM matterInformation) { var matter = matterInformation.Matter; var matterDetails = matterInformation.MatterDetails; var client = matterInformation.Client; int listItemId = -1; string loggedInUserName = ""; bool isEditMode = matterInformation.EditMode; ClientContext clientContext = null; IEnumerable<RoleAssignment> userPermissionOnLibrary = null; GenericResponseVM genericResponse = null; try { bool isFullControlPresent = editFunctions.ValidateFullControlPermission(matter); if (!isFullControlPresent) { return ServiceUtility.GenericResponse(errorSettings.IncorrectInputSelfPermissionRemoval, errorSettings.ErrorEditMatterMandatoryPermission); } genericResponse = matterRepositoy.UpdateMatter(matterInformation); //Need to loop each matter information, update the table storage with that matter information, before sending //notification to external user if (matterInformation.Matter != null && matterInformation.Matter.Roles != null && matterInformation.Matter.Roles.Count > 0) { ShareMatterToExtUser(matterInformation); } } catch (Exception ex) { throw; } return null; }
public GenericResponseVM ShareMatterToExternalUser(MatterInformationVM matterInformation) { return matterRepositoy.ShareMatterToExternalUser(matterInformation); }
/// <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; } } }
/// <summary> /// Updates matter metadata - Stamps properties to the created matter. /// </summary> /// <param name="client">Client object containing Client data</param> /// <param name="details">Term Store object containing Term store data</param> /// <returns>Returns JSON object to the client</returns> /// public IActionResult UpdateMetadata([FromBody]MatterMetdataVM matterMetdata) { string editMatterValidation = string.Empty; var matter = matterMetdata.Matter; var client = matterMetdata.Client; try { spoAuthorization.AccessToken = HttpContext.Request.Headers["Authorization"]; #region Error Checking ErrorResponse errorResponse = null; if (matterMetdata.Client == null && matterMetdata.Matter == null && matterMetdata.MatterDetails == null && matterMetdata.MatterProvisionFlags==null) { errorResponse = new ErrorResponse() { Message = errorSettings.MessageNoInputs, ErrorCode = HttpStatusCode.BadRequest.ToString(), Description = "No input data is passed" }; return matterCenterServiceFunctions.ServiceResponse(errorResponse, (int)HttpStatusCode.BadRequest); } #endregion #region Validations MatterInformationVM matterInfo = new MatterInformationVM() { Client = matterMetdata.Client, Matter = matterMetdata.Matter, MatterDetails = matterMetdata.MatterDetails }; GenericResponseVM genericResponse = validationFunctions.IsMatterValid(matterInfo, int.Parse(ServiceConstants.ProvisionMatterUpdateMetadataForList), matterMetdata.MatterConfigurations); if (genericResponse != null) { matterProvision.DeleteMatter(client, matter); errorResponse = new ErrorResponse() { Message = genericResponse.Value, ErrorCode = genericResponse.Code, }; return matterCenterServiceFunctions.ServiceResponse(errorResponse, (int)HttpStatusCode.BadRequest); } #endregion try { genericResponse = matterProvision.UpdateMatterMetadata(matterMetdata); if (genericResponse == null) { var result = new GenericResponseVM() { Code = "200", Value = "Update Success" }; return matterCenterServiceFunctions.ServiceResponse(result, (int)HttpStatusCode.OK); } return matterCenterServiceFunctions.ServiceResponse(genericResponse, (int)HttpStatusCode.NotModified); } catch(Exception ex) { matterProvision.DeleteMatter(client, matter); customLogger.LogError(ex, MethodBase.GetCurrentMethod().DeclaringType.Name, MethodBase.GetCurrentMethod().Name, logTables.SPOLogTable); throw; } } catch (Exception ex) { customLogger.LogError(ex, MethodBase.GetCurrentMethod().DeclaringType.Name, MethodBase.GetCurrentMethod().Name, logTables.SPOLogTable); throw; } }
public async void Check_Security_Group_Exists() { var blockedUserNames = new List<string>(); blockedUserNames.Add("*****@*****.**"); IList<IList<string>> assignUserNames = new List<IList<string>>(); var userNames = new List<string>(); userNames.Add("Venkat M"); userNames.Add(""); assignUserNames.Add(userNames); IList<IList<string>> assignUserEmails = new List<IList<string>>(); var emails = new List<string>(); emails.Add("*****@*****.**"); emails.Add(""); assignUserEmails.Add(emails); var userIds = new List<string>(); userIds.Add("txtAssign1"); var matterInformationVM = new MatterInformationVM() { Client = new Client() { Url = "https://msmatter.sharepoint.com/sites/microsoft" }, Matter = new Matter() { Name = "New Matter", AssignUserNames = assignUserNames, AssignUserEmails = assignUserEmails, Conflict = new Conflict() { Identified = "True" }, BlockUserNames = blockedUserNames, }, UserIds = userIds }; using (var testClient = testServer.CreateClient().AcceptJson()) { var response = await testClient.PostAsJsonAsync("http://localhost:58775/api/v1/matter/checksecuritygroupexists", matterInformationVM); var result = response.Content.ReadAsJsonAsync<GenericResponseVM>().Result; Assert.NotNull(result); } }
public GenericResponseVM CreateMatterLandingPage(MatterMetdataVM matterMetadataVM) { var client = matterMetadataVM.Client; var matter = matterMetadataVM.Matter; var matterConfigurations = matterMetadataVM.MatterConfigurations; GenericResponseVM genericResponseVM = null; int matterLandingPageId; var matterInformation = new MatterInformationVM() { Client = client, Matter = matter }; genericResponseVM = validationFunctions.IsMatterValid(matterInformation, int.Parse(ServiceConstants.PROVISIONMATTER_MATTER_LANDING_PAGE), matterConfigurations); if (genericResponseVM != null) { return ServiceUtility.GenericResponse(genericResponseVM.Code, genericResponseVM.Value); } //// Create Matter Landing Web Part Page string pageName = string.Format(CultureInfo.InvariantCulture, "{0}{1}", matter.MatterGuid, ServiceConstants.ASPX_EXTENSION); using (ClientContext clientContext = spoAuthorization.GetClientContext(client.Url)) { matterLandingPageId = matterRepositoy.CreateWebPartPage(clientContext, pageName, ServiceConstants.DefaultLayout, ServiceConstants.MasterPageGallery, matterSettings.MatterLandingPageRepositoryName, matter.Name); if (0 <= matterLandingPageId) { Uri uri = new Uri(client.Url); SharePoint.Client.Web web = clientContext.Web; bool isCopyRoleAssignment = CopyRoleAssignment(matter.Conflict.Identified, matter.Conflict.SecureMatter); matterRepositoy.BreakItemPermission(clientContext, matterSettings.MatterLandingPageRepositoryName, matterLandingPageId, isCopyRoleAssignment); matterRepositoy.SetItemPermission(clientContext, matter.AssignUserEmails, matterSettings.MatterLandingPageRepositoryName, matterLandingPageId, matter.Permissions); //// Configure All Web Parts string[] webParts = matterRepositoy.ConfigureXMLCodeOfWebParts(client, matter, clientContext, pageName, uri, web, matterConfigurations); Microsoft.SharePoint.Client.File file = web.GetFileByServerRelativeUrl(string.Format(CultureInfo.InvariantCulture, "{0}{1}{2}{3}{4}", uri.AbsolutePath, ServiceConstants.FORWARD_SLASH, matterSettings.MatterLandingPageRepositoryName.Replace(ServiceConstants.SPACE, string.Empty), ServiceConstants.FORWARD_SLASH, pageName)); clientContext.Load(file); clientContext.ExecuteQuery(); LimitedWebPartManager limitedWebPartManager = file.GetLimitedWebPartManager(PersonalizationScope.Shared); WebPartDefinition webPartDefinition = null; string[] zones = { ServiceConstants.HEADER_ZONE, ServiceConstants.TOP_ZONE, ServiceConstants.RIGHT_ZONE, ServiceConstants.TOP_ZONE, ServiceConstants.RIGHT_ZONE, ServiceConstants.RIGHT_ZONE, ServiceConstants.FOOTER_ZONE, ServiceConstants.RIGHT_ZONE, ServiceConstants.RIGHT_ZONE }; matterRepositoy.AddWebPart(clientContext, limitedWebPartManager, webPartDefinition, webParts, zones); return genericResponseVM; } else { return ServiceUtility.GenericResponse(errorSettings.ErrorCodeMatterLandingPageExists, errorSettings.ErrorCodeMatterLandingPageExists); } } }
public IActionResult UpdateMetadata([FromBody]MatterMetdataVM matterMetdata) { string editMatterValidation = string.Empty; var matter = matterMetdata.Matter; var client = matterMetdata.Client; try { #region Error Checking GenericResponseVM genericResponse = null; if (matterMetdata.Client == null && matterMetdata.Matter == null && matterMetdata.MatterDetails == null && matterMetdata.MatterProvisionFlags == null && matterMetdata.MatterDetails.ManagedColumnTerms==null) { matterProvision.DeleteMatter(matterMetdata as MatterVM); genericResponse = new GenericResponseVM() { Value = errorSettings.MessageNoInputs, Code = HttpStatusCode.BadRequest.ToString(), IsError = true }; return matterCenterServiceFunctions.ServiceResponse(genericResponse, (int)HttpStatusCode.BadRequest); } #endregion #region Validations MatterInformationVM matterInfo = new MatterInformationVM() { Client = matterMetdata.Client, Matter = matterMetdata.Matter, MatterDetails = matterMetdata.MatterDetails }; genericResponse = validationFunctions.IsMatterValid(matterInfo, int.Parse(ServiceConstants.ProvisionMatterUpdateMetadataForList), matterMetdata.MatterConfigurations); if (genericResponse != null) { matterProvision.DeleteMatter(matterMetdata as MatterVM); genericResponse.Description = $"Error occurred while updating the {errorSettings.Item} metadata."; return matterCenterServiceFunctions.ServiceResponse(genericResponse, (int)HttpStatusCode.BadRequest); } #endregion try { genericResponse = matterProvision.UpdateMatterMetadata(matterMetdata); if (genericResponse == null) { genericResponse = new GenericResponseVM() { Code = "200", Value = "Update Success" }; } return matterCenterServiceFunctions.ServiceResponse(genericResponse, (int)HttpStatusCode.OK); } catch (Exception ex) { matterProvision.DeleteMatter(matterMetdata as MatterVM); customLogger.LogError(ex, MethodBase.GetCurrentMethod().DeclaringType.Name, MethodBase.GetCurrentMethod().Name, logTables.SPOLogTable); var errResponse = customLogger.GenerateErrorResponse(ex); return matterCenterServiceFunctions.ServiceResponse(errResponse, (int)HttpStatusCode.InternalServerError); } } catch (Exception ex) { matterProvision.DeleteMatter(matterMetdata as MatterVM); customLogger.LogError(ex, MethodBase.GetCurrentMethod().DeclaringType.Name, MethodBase.GetCurrentMethod().Name, logTables.SPOLogTable); var errResponse = customLogger.GenerateErrorResponse(ex); return matterCenterServiceFunctions.ServiceResponse(errResponse, (int)HttpStatusCode.InternalServerError); } }
private static void SentEmailNotificationForCreatedMatters(MatterInformationVM matterInformation1, ExchangeService service, TextWriter log, IConfigurationRoot configuration) { string mailSubject = configuration.GetSection("Mail").GetSection("MatterMailSubject").Value; string defaultHtmlChunk = configuration.GetSection("Mail").GetSection("MatterMailDefaultContentTypeHtmlChunk").Value; string oneNoteLibrarySuffix = configuration.GetSection("Matter").GetSection("OneNoteLibrarySuffix").Value; string matterMailBodyMatterInformation = configuration.GetSection("Mail").GetSection("MatterMailBodyMatterInformation").Value; string matterMailBodyConflictCheck = configuration.GetSection("Mail").GetSection("MatterMailBodyConflictCheck").Value; string matterCenterDateFormat = configuration.GetSection("Mail").GetSection("MatterCenterDateFormat").Value; string matterMailBodyTeamMembers = configuration.GetSection("Mail").GetSection("MatterMailBodyTeamMembers").Value; //De Serialize the matter information MatterInformationVM originalMatter = JsonConvert.DeserializeObject<MatterInformationVM>(matterInformation1.SerializeMatter); Matter matter = originalMatter.Matter; MatterDetails matterDetails = originalMatter.MatterDetails; Client client = originalMatter.Client; string matterMailBody, blockUserNames; // Generate Mail Subject string matterMailSubject = string.Format(CultureInfo.InvariantCulture, mailSubject, matter.Id, matter.Name, originalMatter.MatterCreator); // Step 1: Create Matter Information string defaultContentType = string.Format(CultureInfo.InvariantCulture, defaultHtmlChunk, matter.DefaultContentType); string matterType = string.Join(";", matter.ContentTypes.ToArray()).TrimEnd(';').Replace(matter.DefaultContentType, defaultContentType); if (matterType == string.Empty) { matterType = 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); string oneNotePath = string.Concat(client.Url, ServiceConstants.FORWARD_SLASH, matter.MatterGuid, oneNoteLibrarySuffix, ServiceConstants.FORWARD_SLASH, matter.MatterGuid, ServiceConstants.FORWARD_SLASH, matter.MatterGuid); if (originalMatter.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, matterMailBodyMatterInformation, client.Name, client.Id, matter.Name, matter.Id, matter.Description, matterType) + string.Format(CultureInfo.InvariantCulture, matterMailBodyConflictCheck, ServiceConstants.YES, matter.Conflict.CheckBy, Convert.ToDateTime(matter.Conflict.CheckOn, CultureInfo.InvariantCulture).ToString(matterCenterDateFormat, CultureInfo.InvariantCulture), conflictIdentified) + string.Format(CultureInfo.InvariantCulture, matterMailBodyTeamMembers, secureMatter, mailBodyTeamInformation, blockUserNames, client.Url, oneNotePath, matter.Name, originalMatter.MatterLocation, matter.Name); } else { blockUserNames = string.Empty; matterMailBody = string.Format(CultureInfo.InvariantCulture, matterMailBodyMatterInformation, client.Name, client.Id, matter.Name, matter.Id, matter.Description, matterType) + string.Format(CultureInfo.InvariantCulture, matterMailBodyTeamMembers, secureMatter, mailBodyTeamInformation, blockUserNames, client.Url, oneNotePath, matter.Name, originalMatter.MatterLocation, matter.Name); } EmailMessage email = new EmailMessage(service); foreach (IList<string> userNames in matter.AssignUserEmails) { foreach (string userName in userNames) { if (!string.IsNullOrWhiteSpace(userName)) { using (var ctx = new ClientContext(originalMatter.Client.Url)) { SecureString password = Utility.GetEncryptedPassword(configuration["General:AdminPassword"]); ctx.Credentials = new SharePointOnlineCredentials(configuration["General:AdminUserName"], password); if (CheckUserPresentInMatterCenter(ctx, originalMatter.Client.Url, userName, null, log)) { if(userName.ToLower().IndexOf("#ext")>0) { string tempUserName = userName.ToLower(); tempUserName = tempUserName.Replace("#ext", "$").Split('$')[0]; tempUserName = ReplaceLastOccurrence(tempUserName, "_", "@"); email.ToRecipients.Add(tempUserName); } else { email.ToRecipients.Add(userName); } } } } } } email.From = new EmailAddress(configuration["General:AdminUserName"]); email.Subject = matterMailSubject; email.Body = matterMailBody; email.Send(); Utility.UpdateTableStorageEntity(originalMatter, log, configuration["General:CloudStorageConnectionString"], configuration["Settings:MatterRequests"], "Accepted", "Status"); }
public IActionResult AssignContentType([FromBody] MatterMetadata matterMetadata) { GenericResponseVM genericResponse = null; if (null == matterMetadata && null == matterMetadata.Client && null == matterMetadata.Matter && matterMetadata.ManagedColumnTerms==null) { genericResponse = new GenericResponseVM() { Value = errorSettings.MessageNoInputs, Code = HttpStatusCode.BadRequest.ToString(), Description = $"No input data is passed to assigncontenttype for the {errorSettings.Item}", IsError = true }; return matterCenterServiceFunctions.ServiceResponse(genericResponse, (int)HttpStatusCode.BadRequest); } // For each value in the list of Content Type Names // Add that content Type to the Library Matter matter = matterMetadata.Matter; Client client = matterMetadata.Client; var matterInformationVM = new MatterInformationVM() { Client = client, Matter = matter, }; try { genericResponse = validationFunctions.IsMatterValid(matterInformationVM, int.Parse(ServiceConstants.ProvisionMatterAssignContentType, CultureInfo.InvariantCulture), null); if (genericResponse != null) { matterProvision.DeleteMatter(matterInformationVM as MatterVM); genericResponse.Description = $"Error occurred when asigning content type to the {errorSettings.Item}"; return matterCenterServiceFunctions.ServiceResponse(genericResponse, (int)HttpStatusCode.BadRequest); } genericResponse = matterProvision.AssignContentType(matterMetadata); if (genericResponse != null && genericResponse.IsError==true) { matterProvision.DeleteMatter(matterInformationVM as MatterVM); genericResponse.Description = $"Error occurred when asigning content type to the {errorSettings.Item}"; return matterCenterServiceFunctions.ServiceResponse(genericResponse, (int)HttpStatusCode.BadRequest); } return matterCenterServiceFunctions.ServiceResponse(genericResponse, (int)HttpStatusCode.OK); } catch (Exception exception) { ///// SharePoint Specific Exception matterProvision.DeleteMatter(matterInformationVM as MatterVM); customLogger.LogError(exception, MethodBase.GetCurrentMethod().DeclaringType.Name, MethodBase.GetCurrentMethod().Name, logTables.SPOLogTable); var errorResponse = customLogger.GenerateErrorResponse(exception); return matterCenterServiceFunctions.ServiceResponse(errorResponse, (int)HttpStatusCode.InternalServerError); } }
/// <summary> /// This method will get all list items from external access requests and process all /// requests which are in accpeted state /// </summary> /// <param name="originalMatter"></param> /// <param name="log"></param> /// <param name="configuration"></param> private static void GetExternalAccessRequestsFromSPO(MatterInformationVM azureTableMatterInformationVMRow, MatterInformationVM originalMatter, TextWriter log, IConfigurationRoot configuration) { try { foreach (var assignUserEmails in originalMatter.Matter.AssignUserEmails) { foreach (string email in assignUserEmails) { using (var ctx = new ClientContext(originalMatter.Client.Url)) { SecureString password = Utility.GetEncryptedPassword(configuration["General:AdminPassword"]); ctx.Credentials = new SharePointOnlineCredentials(configuration["General:AdminUserName"], password); //First check whether the user exists in SharePoint or not log.WriteLine($"Checking whether the user {email} has been present in the system or not"); if (CheckUserPresentInMatterCenter(ctx, originalMatter.Client.Url, email, configuration, log) == true) { string requestedForPerson = email; string matterId = originalMatter.Matter.MatterGuid; var listTitle = configuration["Settings:ExternalAccessRequests"]; var list = ctx.Web.Lists.GetByTitle(listTitle); CamlQuery camlQuery = CamlQuery.CreateAllItemsQuery(); camlQuery.ViewXml = ""; ListItemCollection listItemCollection = list.GetItems(camlQuery); ctx.Load(listItemCollection); ctx.ExecuteQuery(); log.WriteLine($"Looping all the records from {configuration["Settings:ExternalAccessRequests"]} lists"); foreach (ListItem listItem in listItemCollection) { //The matter id for whom the request has been sent string requestedObjectTitle = listItem["RequestedObjectTitle"].ToString(); //The person to whom the request has been sent string requestedFor = listItem["RequestedFor"].ToString(); //The matter url for which the request has been sent string url = ((FieldUrlValue)listItem["RequestedObjectUrl"]).Url; //The status of the request whether it has been in pending=0, accepeted=2 or withdrawn=5 string status = listItem["Status"].ToString(); //If the status is accepted and the person and matter in table storage equals to item in Access Requests list if (requestedFor == requestedForPerson && matterId == requestedObjectTitle && status == "2") { log.WriteLine($"The user {email} has been present in the system and he has accepted the invitation and providing permssions to matter {originalMatter.Matter.Name} from the user {email}"); UpdateMatter umd = new UpdateMatter(); //Update all matter related lists and libraries permissions for external users if (azureTableMatterInformationVMRow.MatterUpdateStatus.ToLower() == "pending") { umd.UpdateUserPermissionsForMatter(originalMatter, configuration, password); Utility.UpdateTableStorageEntity(originalMatter, log, configuration["General:CloudStorageConnectionString"], configuration["Settings:TableStorageForExternalRequests"], "Accepted", "MatterUpdateStatus"); } //Update permissions for external users in Catalog Site Collection using (var catalogContext = new ClientContext(configuration["General:CentralRepositoryUrl"])) { catalogContext.Credentials = new SharePointOnlineCredentials(configuration["General:AdminUserName"], password); umd.AssignPermissionToCatalogLists(configuration["Catalog:SiteAssets"], catalogContext, email.Trim(), configuration["Catalog:SiteAssetsPermissions"], configuration); } log.WriteLine($"The matter permissions has been updated for the user {email}"); log.WriteLine($"Updating the matter status to Accepted in Azure Table Storage"); Utility.UpdateTableStorageEntity(originalMatter, log, configuration["General:CloudStorageConnectionString"], configuration["Settings:TableStorageForExternalRequests"], "Accepted", "Status"); } } } } } } } catch(Exception ex) { log.WriteLine($"Exception occured in the method GetExternalAccessRequestsFromSPO. {ex}"); } }
private static void SentEmailNotificationForCreatedIsBackwardCompatibleMatters(MatterInformationVM matterInformation1, ExchangeService service, TextWriter log, IConfigurationRoot configuration) { string mailSubject = configuration.GetSection("Mail").GetSection("MatterMailSubject").Value; string defaultHtmlChunk = configuration.GetSection("Mail").GetSection("MatterMailDefaultContentTypeHtmlChunk").Value; string oneNoteLibrarySuffix = configuration.GetSection("Matter").GetSection("OneNoteLibrarySuffix").Value; string matterMailBodyMatterInformation = configuration.GetSection("Mail").GetSection("MatterMailBodyMatterInformation").Value; string matterMailBodyConflictCheck = configuration.GetSection("Mail").GetSection("MatterMailBodyConflictCheck").Value; string matterCenterDateFormat = configuration.GetSection("Mail").GetSection("MatterCenterDateFormat").Value; string matterMailBodyTeamMembers = configuration.GetSection("Mail").GetSection("MatterMailBodyTeamMembers").Value; ///For isbackward compatability true MatterInformationVM originalMatter = JsonConvert.DeserializeObject<MatterInformationVM>(matterInformation1.SerializeMatter); Matter matter = originalMatter.Matter; MatterDetails matterDetails = originalMatter.MatterDetails; Client client = originalMatter.Client; string practiceGroupColumnName = configuration["ContentTypes:ManagedColumns:ColumnName1"].ToString(); string areaOfLawColumnName = configuration["ContentTypes:ManagedColumns:ColumnName2"].ToString(); string matterMailBody; string practiceGroupValue = originalMatter.MatterDetails.ManagedColumnTerms[practiceGroupColumnName].TermName; string areaOfLawValue = originalMatter.MatterDetails.ManagedColumnTerms[areaOfLawColumnName].TermName; // Generate Mail Subject string matterMailSubject = string.Format(CultureInfo.InvariantCulture, mailSubject, matter.Id, matter.Name, originalMatter.MatterCreator); // Step 1: Create Matter Information string defaultContentType = string.Format(CultureInfo.InvariantCulture, defaultHtmlChunk, matter.DefaultContentType); string matterType = defaultContentType; if (matterType == string.Empty) { matterType = 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); string oneNotePath = string.Concat(client.Url, ServiceConstants.FORWARD_SLASH, matter.MatterGuid, oneNoteLibrarySuffix, ServiceConstants.FORWARD_SLASH, matter.Name, ServiceConstants.FORWARD_SLASH, matter.MatterGuid); string conflictIdentified = ServiceConstants.FALSE.ToUpperInvariant() == matter.Conflict.Identified.ToUpperInvariant() ? ServiceConstants.NO : ServiceConstants.YES; matterMailBody = string.Format(CultureInfo.InvariantCulture, matterMailBodyMatterInformation, practiceGroupValue, areaOfLawValue, matter.Name, matter.Description, matter.Name + " OneNote", matterType, originalMatter.MatterCreator, string.Format("{0:MMM dd, yyyy}", DateTime.Now), originalMatter.MatterLocation, client.Url, oneNotePath, configuration["General:SiteURL"].ToString()); EmailMessage email = new EmailMessage(service); foreach (IList<string> userNames in matter.AssignUserEmails) { foreach (string userName in userNames) { if (!string.IsNullOrWhiteSpace(userName)) { using (var ctx = new ClientContext(originalMatter.Client.Url)) { SecureString password = Utility.GetEncryptedPassword(configuration["General:AdminPassword"]); ctx.Credentials = new SharePointOnlineCredentials(configuration["General:AdminUserName"], password); if (CheckUserPresentInMatterCenter(ctx, originalMatter.Client.Url, userName, null, log)) { if (userName.ToLower().IndexOf("#ext") > 0) { string tempUserName = userName.ToLower(); tempUserName = tempUserName.Replace("#ext", "$").Split('$')[0]; tempUserName = ReplaceLastOccurrence(tempUserName, "_", "@"); email.ToRecipients.Add(tempUserName); } else { email.ToRecipients.Add(userName); } } } } } } string adminUserName = configuration["General:AdminUserName"]; email.From = new EmailAddress(adminUserName); email.Subject = matterMailSubject; email.Body = matterMailBody; email.Send(); log.WriteLine($"connection string. {configuration["General:CloudStorageConnectionString"]}"); Utility.UpdateTableStorageEntity(originalMatter, log, configuration["General:CloudStorageConnectionString"], configuration["Settings:MatterRequests"], "Accepted", "Status"); }
public async Task<IActionResult> GetTaxonomy([FromBody]TermStoreViewModel termStoreViewModel) { try { #region Error Checking var matterInformation = new MatterInformationVM() { Client = new Client() { Url = termStoreViewModel.Client.Url } }; var genericResponseVM = validationFunctions.IsMatterValid(matterInformation, 0, null); if (genericResponseVM != null) { genericResponseVM.Description = $"Error occurred while getting the taxonomy data"; return matterCenterServiceFunctions.ServiceResponse(genericResponseVM, (int)HttpStatusCode.BadRequest); } #endregion string cacheValue = string.Empty; string key = string.Empty; var details = termStoreViewModel.TermStoreDetails; if (details.TermSetName == taxonomySettings.PracticeGroupTermSetName) { key = ServiceConstants.CACHE_MATTER_TYPE; } else if (details.TermSetName == taxonomySettings.ClientTermSetName) { key = ServiceConstants.CACHE_CLIENTS; } ServiceUtility.RedisCacheHostName = generalSettings.RedisCacheHostName; cacheValue = ServiceUtility.GetDataFromAzureRedisCache(key); //cacheValue = ""; TaxonomyResponseVM taxonomyRepositoryVM = null; if (String.IsNullOrEmpty(cacheValue)) { taxonomyRepositoryVM = await taxonomyRepository.GetTaxonomyHierarchyAsync(termStoreViewModel); if (termStoreViewModel.TermStoreDetails.TermSetName == taxonomySettings.PracticeGroupTermSetName && taxonomyRepositoryVM.TermSets!=null) { ServiceUtility.SetDataIntoAzureRedisCache<string>(key, taxonomyRepositoryVM.TermSets); return matterCenterServiceFunctions.ServiceResponse(taxonomyRepositoryVM.TermSets, (int)HttpStatusCode.OK); } if (termStoreViewModel.TermStoreDetails.TermSetName == taxonomySettings.ClientTermSetName && taxonomyRepositoryVM.ClientTermSets != null) { ServiceUtility.SetDataIntoAzureRedisCache<ClientTermSets>(key, taxonomyRepositoryVM.ClientTermSets); return matterCenterServiceFunctions.ServiceResponse(taxonomyRepositoryVM.ClientTermSets, (int)HttpStatusCode.OK); } } else { if (termStoreViewModel.TermStoreDetails.TermSetName == taxonomySettings.PracticeGroupTermSetName) { var pgTermSets = JsonConvert.DeserializeObject<string>(cacheValue); if (pgTermSets == null) { genericResponseVM = new GenericResponseVM() { Value = errorSettings.MessageNoResult, Code = "404", Description = "No data is present for the given passed input" }; return matterCenterServiceFunctions.ServiceResponse(genericResponseVM, (int)HttpStatusCode.NotFound); } return matterCenterServiceFunctions.ServiceResponse(pgTermSets, (int)HttpStatusCode.OK); } if (termStoreViewModel.TermStoreDetails.TermSetName == taxonomySettings.ClientTermSetName) { var clientTermSets = JsonConvert.DeserializeObject<ClientTermSets>(cacheValue); if (clientTermSets == null) { genericResponseVM = new GenericResponseVM() { Value = errorSettings.MessageNoResult, Code = HttpStatusCode.NotFound.ToString(), Description = "No data is present for the given passed input" }; return matterCenterServiceFunctions.ServiceResponse(genericResponseVM, (int)HttpStatusCode.NotFound); } return matterCenterServiceFunctions.ServiceResponse(clientTermSets, (int)HttpStatusCode.OK); } } //If all the above condition fails, return validation error object genericResponseVM = new GenericResponseVM() { Value = errorSettings.MessageNoResult, Code = HttpStatusCode.NotFound.ToString(), Description = "No data is present for the given passed input" }; return matterCenterServiceFunctions.ServiceResponse(genericResponseVM, (int)HttpStatusCode.BadRequest); } catch(Exception ex) { customLogger.LogError(ex, MethodBase.GetCurrentMethod().DeclaringType.Name, MethodBase.GetCurrentMethod().Name, logTables.SPOLogTable); var errorResponse = customLogger.GenerateErrorResponse(ex); return matterCenterServiceFunctions.ServiceResponse(errorResponse, (int)HttpStatusCode.InternalServerError); } }
public GenericResponseVM IsMatterValid(MatterInformationVM matterInformation, int methodNumber, MatterConfigurations matterConfigurations) { GenericResponseVM genericResponse = null; var matterDetails = matterInformation.MatterDetails; if (int.Parse(ServiceConstants.ProvisionMatterCreateMatter, CultureInfo.InvariantCulture) <= methodNumber && int.Parse(ServiceConstants.EditMatterPermission, CultureInfo.InvariantCulture) >= methodNumber && !spList.CheckPermissionOnList(matterSettings.ProvisionMatterAppURL, matterSettings.SendMailListName, PermissionKind.EditListItems)) { genericResponse = new GenericResponseVM(); //return string.Format(CultureInfo.InvariantCulture, ConstantStrings.ServiceResponse, ServiceConstantStrings.IncorrectInputUserAccessCode, ServiceConstantStrings.IncorrectInputUserAccessMessage); genericResponse.Code = errorSettings.IncorrectInputUserAccessCode; genericResponse.Value = errorSettings.IncorrectInputUserAccessMessage; } else { if (matterInformation.Client!=null) { genericResponse = new GenericResponseVM(); genericResponse = ValidateClientInformation(matterInformation.Client, methodNumber); if (genericResponse!=null) { return genericResponse; } } if (matterInformation.Matter!=null) { genericResponse = MatterMetadataValidation(matterInformation.Matter, matterInformation.Client, methodNumber, matterConfigurations); if (genericResponse!=null) { return genericResponse; } if (int.Parse(ServiceConstants.EditMatterPermission, CultureInfo.InvariantCulture) == methodNumber) { genericResponse = RoleCheck(matterInformation.Matter); if (genericResponse!=null) { return genericResponse; } } if (matterInformation.Matter.Permissions!=null) { bool isFullControlPresent = ValidateFullControlPermission(matterInformation.Matter); if (!isFullControlPresent) { return GenericResponse(errorSettings.IncorrectInputUserAccessCode, errorSettings.ErrorEditMatterMandatoryPermission); } } } if (null != matterDetails && !(int.Parse(ServiceConstants.EditMatterPermission, CultureInfo.InvariantCulture) == methodNumber)) { if (string.IsNullOrWhiteSpace(matterDetails.PracticeGroup)) { return GenericResponse(errorSettings.IncorrectInputPracticeGroupCode, errorSettings.IncorrectInputPracticeGroupMessage); } if (string.IsNullOrWhiteSpace(matterDetails.AreaOfLaw)) { return GenericResponse(errorSettings.IncorrectInputAreaOfLawCode, errorSettings.IncorrectInputAreaOfLawMessage); } if (string.IsNullOrWhiteSpace(matterDetails.SubareaOfLaw)) { return GenericResponse(errorSettings.IncorrectInputSubareaOfLawCode, errorSettings.IncorrectInputSubareaOfLawMessage); } try { if (string.IsNullOrWhiteSpace(matterDetails.ResponsibleAttorney)) { return GenericResponse(errorSettings.IncorrectInputResponsibleAttorneyCode, errorSettings.IncorrectInputResponsibleAttorneyMessage); } else { IList<string> userNames = matterDetails.ResponsibleAttorney.Split(';').ToList<string>(); matterRespository.ResolveUserNames(matterInformation.Client, userNames).FirstOrDefault(); } } catch (Exception) { return GenericResponse(errorSettings.IncorrectInputResponsibleAttorneyCode, errorSettings.IncorrectInputResponsibleAttorneyMessage); } } } return genericResponse; }
public GenericResponseVM UpdateMatter(MatterInformationVM matterInformation) { var matter = matterInformation.Matter; var matterDetails = matterInformation.MatterDetails; var client = matterInformation.Client; int listItemId = -1; string loggedInUserName = ""; bool isEditMode = matterInformation.EditMode; ClientContext clientContext = null; IEnumerable<RoleAssignment> userPermissionOnLibrary = null; GenericResponseVM genericResponse = null; try { clientContext = spoAuthorization.GetClientContext(matterInformation.Client.Url); PropertyValues matterStampedProperties = matterRepositoy.GetStampedProperties(clientContext, matter.Name); loggedInUserName = matterRepositoy.GetLoggedInUserDetails(clientContext).Name; bool isFullControlPresent = editFunctions.ValidateFullControlPermission(matter); if (!isFullControlPresent) { return ServiceUtility.GenericResponse(errorSettings.IncorrectInputSelfPermissionRemoval, errorSettings.ErrorEditMatterMandatoryPermission); } // Get matter library current permissions userPermissionOnLibrary = matterRepositoy.FetchUserPermissionForLibrary(clientContext, matter.Name); string originalMatterName = matterRepositoy.GetMatterName(clientContext, matter.Name); listItemId = matterRepositoy.RetrieveItemId(clientContext, matterSettings.MatterLandingPageRepositoryName, originalMatterName); List<string> usersToRemove = RetrieveMatterUsers(userPermissionOnLibrary); bool hasFullPermission = CheckFullPermissionInAssignList(matter.AssignUserNames, matter.Permissions, loggedInUserName); List<string> listExists = matterRepositoy.MatterAssociatedLists(clientContext, matter.Name); matterRepositoy.AssignRemoveFullControl(clientContext, matter, loggedInUserName, listItemId, listExists, true, hasFullPermission); bool result = false; if (listExists.Contains(matter.Name)) { result = matterRepositoy.UpdatePermission(clientContext, matter, usersToRemove, loggedInUserName, false, matter.Name, -1, isEditMode); } if (listExists.Contains(matter.Name + matterSettings.OneNoteLibrarySuffix)) { result = matterRepositoy.UpdatePermission(clientContext, matter, usersToRemove, loggedInUserName, false, matter.Name + matterSettings.OneNoteLibrarySuffix, -1, isEditMode); } if (listExists.Contains(matter.Name + matterSettings.CalendarNameSuffix)) { result = matterRepositoy.UpdatePermission(clientContext, matter, usersToRemove, loggedInUserName, false, matter.Name + matterSettings.CalendarNameSuffix, -1, isEditMode); } if (listExists.Contains(matter.Name + matterSettings.TaskNameSuffix)) { result = matterRepositoy.UpdatePermission(clientContext, matter, usersToRemove, loggedInUserName, false, matter.Name + matterSettings.TaskNameSuffix, -1, isEditMode); } if (0 <= listItemId) { result = matterRepositoy.UpdatePermission(clientContext, matter, usersToRemove, loggedInUserName, true, matterSettings.MatterLandingPageRepositoryName, listItemId, isEditMode); } // Update matter metadata result = matterRepositoy.UpdateMatterStampedProperties(clientContext, matterDetails, matter, matterStampedProperties, isEditMode); if(result) { return genericResponse; } } catch(Exception ex) { MatterRevertList matterRevertListObject = new MatterRevertList() { MatterLibrary = matter.Name, MatterOneNoteLibrary = matter.Name + matterSettings.OneNoteLibrarySuffix, MatterCalendar = matter.Name + matterSettings.CalendarNameSuffix, MatterTask = matter.Name + matterSettings.TaskNameSuffix, MatterSitePages = matterSettings.MatterLandingPageRepositoryName }; matterRepositoy.RevertMatterUpdates(client, matter, clientContext, matterRevertListObject, loggedInUserName, userPermissionOnLibrary, listItemId, isEditMode); } return ServiceUtility.GenericResponse("9999999", "Error in updating matter information"); }