/// <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");
}
