public bool CheckNormalDocuments(RequestObject requestObject, SyncDetails syncDetails)
{
ClientContext clientContext = null;
bool response = false;
try
{
if (null != requestObject && null != syncDetails && ValidationHelperFunctions.CheckRequestValidatorToken())
{
string usersMySite = BriefcaseHelperFunction.GetPersonalURL(requestObject);
if (!string.IsNullOrEmpty(usersMySite))
{
using (clientContext = ServiceUtility.GetClientContext(requestObject.SPAppToken, new Uri(usersMySite), requestObject.RefreshToken))
{
List <string> sourceURL = BriefcaseHelperFunction.CheckSourceURL(clientContext, syncDetails, 1);
if (0 == sourceURL.Count)
{
response = true;
}
}
}
}
}
catch (Exception exception)
{
Logger.LogError(exception, MethodBase.GetCurrentMethod().DeclaringType.Name, MethodBase.GetCurrentMethod().Name, ServiceConstantStrings.LogTableName);
}
return(response);
}
public string UploadMail(RequestObject requestObject, Client client, ServiceRequest serviceRequest)
{
string message = string.Empty;
string result = "True";
if (null != requestObject && null != client && null != serviceRequest && ValidationHelperFunctions.CheckRequestValidatorToken())
{
if (UploadHelperFunctions.Upload(requestObject, client, serviceRequest, ServiceConstantStrings.MailSoapRequest, serviceRequest.MailId, true, serviceRequest.Subject, serviceRequest.FolderPath[0], true, ref message, string.Empty).Equals(ConstantStrings.UploadFailed))
{
if (!string.IsNullOrEmpty(message))
{
result = message;
}
else
{
result = "False";
}
}
}
else
{
result = TextConstants.MessageNoInputs;
}
return(result);
}
public string PinDocumentForUser(RequestObject requestObject, Client client, DocumentData documentData)
{
string status = string.Empty;
if (null != requestObject && null != client && null != documentData && ValidationHelperFunctions.CheckRequestValidatorToken())
{
////Create document object and populate meta-data
DocumentData userPinnedDocumentData = new DocumentData()
{
DocumentName = SearchHelperFunctions.EncodeValues(documentData.DocumentName),
DocumentVersion = SearchHelperFunctions.EncodeValues(documentData.DocumentVersion),
DocumentClient = SearchHelperFunctions.EncodeValues(documentData.DocumentClient),
DocumentClientId = SearchHelperFunctions.EncodeValues(documentData.DocumentClientId),
DocumentClientUrl = SearchHelperFunctions.EncodeValues(documentData.DocumentClientUrl),
DocumentMatter = SearchHelperFunctions.EncodeValues(documentData.DocumentMatter),
DocumentMatterId = SearchHelperFunctions.EncodeValues(documentData.DocumentMatterId),
DocumentOwner = SearchHelperFunctions.EncodeValues(documentData.DocumentOwner),
DocumentUrl = SearchHelperFunctions.EncodeValues(documentData.DocumentUrl),
DocumentOWAUrl = SearchHelperFunctions.EncodeValues(documentData.DocumentOWAUrl),
DocumentExtension = SearchHelperFunctions.EncodeValues(documentData.DocumentExtension),
DocumentCreatedDate = SearchHelperFunctions.EncodeValues(documentData.DocumentCreatedDate),
DocumentModifiedDate = SearchHelperFunctions.EncodeValues(documentData.DocumentModifiedDate),
DocumentCheckoutUser = SearchHelperFunctions.EncodeValues(documentData.DocumentCheckoutUser),
DocumentMatterUrl = SearchHelperFunctions.EncodeValues(documentData.DocumentMatterUrl),
DocumentParentUrl = SearchHelperFunctions.EncodeValues(documentData.DocumentParentUrl),
DocumentID = SearchHelperFunctions.EncodeValues(documentData.DocumentID)
};
status = SearchHelperFunctions.PopulateMetadeta(requestObject, client, null, userPinnedDocumentData);
}
else
{
status = TextConstants.MessageNoInputs;
}
return(status);
}
public string PinMatterForUser(RequestObject requestObject, Client client, MatterData matterData)
{
string status = string.Empty;
if (null != requestObject && null != client && null != matterData && ValidationHelperFunctions.CheckRequestValidatorToken())
{
////Create matter object and populate meta-data
MatterData userPinnedMatterData = new MatterData()
{
MatterName = SearchHelperFunctions.EncodeValues(matterData.MatterName),
MatterDescription = SearchHelperFunctions.EncodeValues(matterData.MatterDescription),
MatterCreatedDate = SearchHelperFunctions.EncodeValues(matterData.MatterCreatedDate),
MatterUrl = SearchHelperFunctions.EncodeValues(matterData.MatterUrl),
MatterPracticeGroup = SearchHelperFunctions.EncodeValues(matterData.MatterPracticeGroup),
MatterAreaOfLaw = SearchHelperFunctions.EncodeValues(matterData.MatterAreaOfLaw),
MatterSubAreaOfLaw = SearchHelperFunctions.EncodeValues(matterData.MatterSubAreaOfLaw),
MatterClientUrl = SearchHelperFunctions.EncodeValues(matterData.MatterClientUrl),
MatterClient = SearchHelperFunctions.EncodeValues(matterData.MatterClient),
MatterClientId = SearchHelperFunctions.EncodeValues(matterData.MatterClientId),
HideUpload = SearchHelperFunctions.EncodeValues(matterData.HideUpload),
MatterID = SearchHelperFunctions.EncodeValues(matterData.MatterID),
MatterResponsibleAttorney = SearchHelperFunctions.EncodeValues(matterData.MatterResponsibleAttorney),
MatterModifiedDate = SearchHelperFunctions.EncodeValues(matterData.MatterModifiedDate),
MatterGuid = SearchHelperFunctions.EncodeValues(matterData.MatterGuid)
};
status = SearchHelperFunctions.PopulateMetadeta(requestObject, client, userPinnedMatterData, null);
}
else
{
status = TextConstants.MessageNoInputs;
}
return(status);
}
public string DiscardCheckOutChanges(RequestObject requestObject, MailAttachmentDetails mailAttachmentDetails)
{
string result = null;
try
{
if (null != requestObject && null != mailAttachmentDetails && ValidationHelperFunctions.CheckRequestValidatorToken())
{
///// full URL, relative URL
string[] allAttachmentUrl = mailAttachmentDetails.FullUrl.Split(';');
foreach (string attachmentUrl in allAttachmentUrl)
{
if (!string.IsNullOrWhiteSpace(attachmentUrl))
{
MailAttachmentDetails sendDocumentUrl = new MailAttachmentDetails();
sendDocumentUrl.FullUrl = attachmentUrl;
result = BriefcaseHelperFunction.DiscardCheckout(requestObject, sendDocumentUrl);
}
}
}
}
catch (Exception exception)
{
Logger.LogError(exception, MethodBase.GetCurrentMethod().DeclaringType.Name, MethodBase.GetCurrentMethod().Name, ServiceConstantStrings.LogTableName);
result = string.Concat(ConstantStrings.FALSE, ConstantStrings.Comma, ConstantStrings.Space, ServiceUtility.RemoveEscapeCharacter(exception.Message));
}
return(result);
}
public string RemovePinnedDocument(RequestObject requestObject, Client client, DocumentData documentData)
{
string status = string.Empty;
if (null != requestObject && null != client && null != documentData && ValidationHelperFunctions.CheckRequestValidatorToken())
{
status = SearchHelperFunctions.UnpinItem(requestObject, client, null, documentData);
}
else
{
status = TextConstants.MessageNoInputs;
}
return(status);
}
public string GetFileRelativeLocation(RequestObject requestObject, string listId, string[] listItemId, string currentLocation)
{
string response = string.Empty;
bool hasFolder = false;
try
{
if (null != requestObject && null != listId && null != listItemId && ValidationHelperFunctions.CheckRequestValidatorToken())
{
ClientContext clientContext = null;
using (clientContext = ServiceUtility.GetClientContext(requestObject.SPAppToken, new Uri(currentLocation), requestObject.RefreshToken))
{
List list = clientContext.Web.Lists.GetById(new Guid(listId));
int iterator = 0, length = listItemId.Length;
for (iterator = 0; iterator < length; iterator++)
{
ListItem listItem = list.GetItemById(listItemId[iterator]);
clientContext.Load(listItem, item => item.File.ServerRelativeUrl, item => item.FileSystemObjectType);
clientContext.ExecuteQuery();
if (listItem.FileSystemObjectType == FileSystemObjectType.File)
{
response += currentLocation + ConstantStrings.DOLLAR + listItem.File.ServerRelativeUrl;
if (iterator < length - 1)
{
response += ConstantStrings.Semicolon;
}
}
else
{
hasFolder = true;
break;
}
}
if (hasFolder)
{
response = ConstantStrings.FALSE;
}
}
}
}
catch (Exception exception)
{
////Generic Exception
response = Logger.LogError(exception, MethodBase.GetCurrentMethod().DeclaringType.Name, MethodBase.GetCurrentMethod().Name, ServiceConstantStrings.LogTableName);
}
return(response);
}
public Stream SaveEmail(RequestObject requestObject, MailAttachmentDetails mailAttachmentDetails)
{
Stream result = null;
try
{
if (null != requestObject && null != mailAttachmentDetails && ValidationHelperFunctions.CheckRequestValidatorToken())
{
///// filename, stream
Dictionary <string, Stream> collectionOfAttachments = new Dictionary <string, Stream>();
///// full URL, relative URL
string[] allAttachmentUrl = mailAttachmentDetails.FullUrl.Split(';');
ClientContext clientContext;
bool attachmentFlag = mailAttachmentDetails.IsAttachmentCall;
if (attachmentFlag)
{
foreach (string attachmentUrl in allAttachmentUrl)
{
if (!string.IsNullOrWhiteSpace(attachmentUrl))
{
// Do not use 'using' to generate client context here since it will dispose the object before other functions get executed
clientContext = ServiceUtility.GetClientContext(requestObject.SPAppToken, new Uri(attachmentUrl.Split(Convert.ToChar(ConstantStrings.DOLLAR, CultureInfo.InvariantCulture))[0]), requestObject.RefreshToken);
Microsoft.SharePoint.Client.File file = clientContext.Web.GetFileByServerRelativeUrl(attachmentUrl.Split(Convert.ToChar(ConstantStrings.DOLLAR, CultureInfo.InvariantCulture))[1]);
ClientResult <System.IO.Stream> fileStream = file.OpenBinaryStream();
///// Load the Stream data for the file
clientContext.Load(file);
clientContext.ExecuteQuery();
///// In order to allow for multiple files with the same name, we provide a GUID tag to ensure unique keys in the dictionary
string uniqueKeyWithDate = attachmentUrl.Split(Convert.ToChar(ConstantStrings.DOLLAR, CultureInfo.InvariantCulture))[1].Substring(attachmentUrl.Split(Convert.ToChar(ConstantStrings.DOLLAR, CultureInfo.InvariantCulture))[1].LastIndexOf(Convert.ToChar(ConstantStrings.BackwardSlash, CultureInfo.InvariantCulture)) + 1) + ConstantStrings.DOLLAR + Guid.NewGuid();
collectionOfAttachments.Add(uniqueKeyWithDate, fileStream.Value);
}
}
}
result = MailHelperFunctions.GenerateEmail(collectionOfAttachments, allAttachmentUrl, attachmentFlag);
}
else
{
result = BriefcaseHelperFunction.ReturnErrorFile(TextConstants.MessageNoInputs);
}
}
catch (Exception exception)
{
Logger.LogError(exception, MethodBase.GetCurrentMethod().DeclaringType.Name, MethodBase.GetCurrentMethod().Name, ServiceConstantStrings.LogTableName);
result = BriefcaseHelperFunction.ReturnErrorFile(string.Concat(ConstantStrings.ServiceResponse, exception.HResult, exception.Message));
}
return(result);
}
public string UploadAttachment(RequestObject requestObject, Client client, ServiceRequest serviceRequest)
{
string resultFlag = string.Empty;
if (null != requestObject && null != client && null != serviceRequest && ValidationHelperFunctions.CheckRequestValidatorToken())
{
///// check if folder path and attachment length are same
if (serviceRequest.FolderPath.Count == serviceRequest.Attachments.Count)
{
bool result = true;
///// StringBuilder builder = new StringBuilder();
int attachmentCount = 0;
string message = string.Empty;
foreach (AttachmentDetails attachment in serviceRequest.Attachments)
{
if (UploadHelperFunctions.Upload(requestObject, client, serviceRequest, ServiceConstantStrings.AttachmentSoapRequest, attachment.id, false, attachment.name, serviceRequest.FolderPath[attachmentCount], true, ref message, attachment.originalName).Equals(ConstantStrings.UploadFailed))
{
result = false;
break;
}
attachmentCount++;
}
if (result)
{
resultFlag = "True";
}
else if (!string.IsNullOrEmpty(message))
{
resultFlag = message;
}
else
{
resultFlag = "False";
}
}
else
{
resultFlag = "False";
}
}
else
{
resultFlag = TextConstants.MessageNoInputs;
}
return(resultFlag);
}
public string FindUserPinnedDocument(RequestObject requestObject, Client client)
{
string result = string.Empty;
if (null != requestObject && null != client && ValidationHelperFunctions.CheckRequestValidatorToken())
{
result = SearchHelperFunctions.ShowPinData(requestObject, client, ServiceConstantStrings.UserPinnedDocumentListName, ServiceConstantStrings.PinnedListColumnDocumentDetails, true);
// Decode pinned documents
result = HttpUtility.HtmlDecode(result);
}
else
{
result = TextConstants.MessageNoInputs;
}
return(result);
}
public string FindUserPinnedMatter(RequestObject requestObject, Client client)
{
string result = string.Empty;
if (null != requestObject && null != client && ValidationHelperFunctions.CheckRequestValidatorToken())
{
result = SearchHelperFunctions.ShowPinData(requestObject, client, ServiceConstantStrings.UserPinnedMatterListName, ServiceConstantStrings.PinnedListColumnMatterDetails, false);
// Decode pinned documents
result = HttpUtility.HtmlDecode(result);
}
else
{
result = string.Format(CultureInfo.InvariantCulture, ConstantStrings.ServiceResponse, string.Empty, TextConstants.MessageNoInputs);
}
return(result);
}
public string SyncBriefcase(RequestObject requestObject, SyncDetails syncDetails)
{
CommonResponse commonResponse = new CommonResponse();
try
{
if (null != requestObject && null != syncDetails && ValidationHelperFunctions.CheckRequestValidatorToken())
{
string usersMySite = string.Empty;
ClientContext clientContext = null;
usersMySite = BriefcaseHelperFunction.GetPersonalURL(requestObject);
if (!string.IsNullOrEmpty(usersMySite))
{
using (clientContext = ServiceUtility.GetClientContext(requestObject.SPAppToken, new Uri(usersMySite), requestObject.RefreshToken))
{
string status = string.Empty;
List <string> sourceURL = BriefcaseHelperFunction.CheckSourceURL(clientContext, syncDetails, 1);
if (sourceURL.Count != 0)
{
return(BriefcaseHelperFunction.GetNotSupportedMessage(sourceURL));
}
GetContextInList(requestObject, syncDetails, ref commonResponse, clientContext, ref status);
}
}
else
{
commonResponse.ErrorMessage = ServiceConstantStrings.UserMySiteNotPresent;
}
}
else
{
commonResponse.Status.Add(false);
commonResponse.ErrorMessage = TextConstants.InvalidParametersMessage;
}
}
catch (Exception exception)
{
commonResponse.Status.Add(false);
commonResponse.ErrorMessage = ServiceUtility.RemoveEscapeCharacter(exception.Message);
}
return(BriefcaseHelperFunction.GetSerializeResponse(commonResponse));
}
public string GetDocumentAssets(RequestObject requestObject, Client client)
{
string result = string.Empty;
if (null != requestObject && null != client && ValidationHelperFunctions.CheckRequestValidatorToken())
{
try
{
using (ClientContext clientContext = ServiceUtility.GetClientContext(requestObject.SPAppToken, new Uri(client.Url), requestObject.RefreshToken))
{
result = SearchHelperFunctionsUtility.GetDocumentAndClientGUID(client, clientContext);
}
}
catch (Exception exception)
{
result = Logger.LogError(exception, MethodBase.GetCurrentMethod().DeclaringType.Name, MethodBase.GetCurrentMethod().Name, ServiceConstantStrings.LogTableName);
}
}
return(result);
}
public string CheckOutDocument(RequestObject requestObject, MailAttachmentDetails mailAttachmentDetails)
{
string returnFlag = ConstantStrings.FALSE;
if (null != requestObject && null != mailAttachmentDetails && ValidationHelperFunctions.CheckRequestValidatorToken())
{
string result = ConstantStrings.FALSE;
ClientContext clientContext;
try
{
using (clientContext = ServiceUtility.GetClientContext(requestObject.SPAppToken, new Uri(mailAttachmentDetails.FullUrl.Split(Convert.ToChar(ConstantStrings.DOLLAR, CultureInfo.InvariantCulture))[0]), requestObject.RefreshToken))
{
Microsoft.SharePoint.Client.File file = clientContext.Web.GetFileByServerRelativeUrl(mailAttachmentDetails.FullUrl.Split(Convert.ToChar(ConstantStrings.DOLLAR, CultureInfo.InvariantCulture))[1].TrimEnd(ConstantStrings.Semicolon[0]));
clientContext.Load(file);
clientContext.ExecuteQuery();
if (file.CheckOutType == CheckOutType.None)
{
file.CheckOut();
result = string.Concat(ConstantStrings.TRUE, ConstantStrings.Comma, ConstantStrings.Space, file.Name);
}
else
{
result = string.Concat(ConstantStrings.FALSE, ConstantStrings.Comma, ServiceConstantStrings.AlreadyCheckOut);
}
clientContext.ExecuteQuery();
returnFlag = result;
}
}
catch (Exception exception)
{
Logger.LogError(exception, MethodBase.GetCurrentMethod().DeclaringType.Name, MethodBase.GetCurrentMethod().Name, ServiceConstantStrings.LogTableName);
returnFlag = string.Concat(ConstantStrings.FALSE, ConstantStrings.Comma, ConstantStrings.Space, ServiceUtility.RemoveEscapeCharacter(exception.Message));
}
}
else
{
returnFlag = string.Concat(ConstantStrings.FALSE, ConstantStrings.Comma, ConstantStrings.Space, TextConstants.InvalidParametersMessage);
}
return(returnFlag);
}
public string GetFolderHierarchy(RequestObject requestObject, MatterData matterData)
{
string result = string.Empty;
if (null != requestObject && null != matterData && ValidationHelperFunctions.CheckRequestValidatorToken())
{
try
{
if (!string.IsNullOrWhiteSpace(matterData.MatterName) && !string.IsNullOrWhiteSpace(matterData.MatterUrl))
{
using (ClientContext clientContext = ServiceUtility.GetClientContext(requestObject.SPAppToken, new Uri(matterData.MatterUrl), requestObject.RefreshToken))
{
List list = clientContext.Web.Lists.GetByTitle(matterData.MatterName);
clientContext.Load(list.RootFolder);
ListItemCollection listItems = Lists.GetData(clientContext, matterData.MatterName, string.Format(CultureInfo.InvariantCulture, ServiceConstantStrings.AllFoldersQuery, matterData.MatterName));
List <FolderData> allFolders = new List <FolderData>();
allFolders = SearchHelperFunctions.GetFolderAssignment(list, listItems, allFolders);
result = JsonConvert.SerializeObject(allFolders);
}
}
else
{
result = string.Format(CultureInfo.InvariantCulture, ConstantStrings.ServiceResponse, 0, TextConstants.MessageNoInputs);
}
}
catch (Exception exception)
{
result = Logger.LogError(exception, MethodBase.GetCurrentMethod().DeclaringType.Name, MethodBase.GetCurrentMethod().Name, ServiceConstantStrings.LogTableName);
}
}
else
{
result = TextConstants.MessageNoInputs;
}
return(result);
}
public string FindDocument(RequestObject requestObject, Client client, SearchObject searchObject)
{
string result = string.Empty;
if (null != requestObject && null != client & null != searchObject && ValidationHelperFunctions.CheckRequestValidatorToken())
{
try
{
// Encode all fields which are coming from js
SearchHelperFunctions.EncodeSearchDetails(searchObject.Filters, false);
// Encode Search Term
searchObject.SearchTerm = (null != searchObject.SearchTerm) ? Encoder.HtmlEncode(searchObject.SearchTerm).Replace(ConstantStrings.ENCODEDDOUBLEQUOTES, ConstantStrings.DoubleQuote) : string.Empty;
using (ClientContext clientContext = ServiceUtility.GetClientContext(requestObject.SPAppToken, new Uri(client.Url), requestObject.RefreshToken))
{
KeywordQuery keywordQuery = new KeywordQuery(clientContext);
if (string.IsNullOrWhiteSpace(searchObject.SearchTerm))
{
searchObject.SearchTerm = ConstantStrings.Asterisk;
}
if (null != searchObject.Filters)
{
if (1 == searchObject.Filters.FilterByMe)
{
// Get the current logged in User
clientContext.Load(clientContext.Web.CurrentUser);
clientContext.ExecuteQuery();
string currentLoggedInUser = clientContext.Web.CurrentUser.Title;
searchObject.SearchTerm = String.Concat(searchObject.SearchTerm, ConstantStrings.Space, ConstantStrings.OperatorAnd, ConstantStrings.Space, SearchConstants.ManagedPropertyAuthor, ConstantStrings.COLON, currentLoggedInUser);
}
keywordQuery = SearchHelperFunctions.FilterDocuments(searchObject, keywordQuery);
}
keywordQuery = SearchHelperFunctions.KeywordQueryMetrics(client, searchObject, keywordQuery, ConstantStrings.DocumentItemFilterCondition, SearchConstants.ManagedPropertyIsDocument, false);
//// Create a list of managed properties which are required to be present in search results
List <string> managedProperties = new List <string>();
managedProperties.Add(SearchConstants.ManagedPropertyFileName);
managedProperties.Add(SearchConstants.ManagedPropertyTitle);
managedProperties.Add(SearchConstants.ManagedPropertyCreated);
managedProperties.Add(SearchConstants.ManagedPropertyUIVersionStringOWSTEXT);
managedProperties.Add(SearchConstants.ManagedPropertyServerRelativeUrl);
managedProperties.Add(SearchConstants.ManagedPropertyFileExtension);
managedProperties.Add(SearchConstants.ManagedPropertyDocumentMatterId);
managedProperties.Add(SearchConstants.ManagedPropertyDocumentLastModifiedTime);
managedProperties.Add(SearchConstants.ManagedPropertySiteTitle);
managedProperties.Add(SearchConstants.ManagedPropertyDocumentClientId);
managedProperties.Add(SearchConstants.ManagedPropertyDocumentClientName);
managedProperties.Add(SearchConstants.ManagedPropertyDocumentMatterName);
managedProperties.Add(SearchConstants.ManagedPropertyDocumentId);
managedProperties.Add(SearchConstants.ManagedPropertyCheckOutByUser);
managedProperties.Add(SearchConstants.ManagedPropertySiteName);
managedProperties.Add(SearchConstants.ManagedPropertySPWebUrl);
managedProperties.Add(SearchConstants.ManagedPropertyDocumentVersion);
managedProperties.Add(SearchConstants.ManagedPropertyDocumentCheckOutUser);
managedProperties.Add(SearchConstants.ManagedPropertySPWebUrl);
managedProperties.Add(SearchConstants.ManagedPropertyAuthor);
//Filter on Result source to fetch only Matter Center specific results
keywordQuery.SourceId = new Guid(SearchConstants.SearchResultSourceID);
keywordQuery = SearchHelperFunctions.AssignKeywordQueryValues(keywordQuery, managedProperties);
result = SearchHelperFunctions.FillResultData(clientContext, keywordQuery, searchObject, false, managedProperties);
}
}
catch (Exception exception)
{
result = Logger.LogError(exception, MethodBase.GetCurrentMethod().DeclaringType.Name, MethodBase.GetCurrentMethod().Name, ServiceConstantStrings.LogTableName);
}
}
else
{
result = TextConstants.MessageNoInputs;
}
return(result);
}
public string FindMatter(RequestObject requestObject, Client client, SearchObject searchObject)
{
string result = string.Empty;
if (null != requestObject && null != client & null != searchObject && ValidationHelperFunctions.CheckRequestValidatorToken())
{
try
{
// Encode all fields which are coming from js
SearchHelperFunctions.EncodeSearchDetails(searchObject.Filters, true);
// Encode Search Term
searchObject.SearchTerm = (null != searchObject.SearchTerm) ? Encoder.HtmlEncode(searchObject.SearchTerm).Replace(ConstantStrings.ENCODEDDOUBLEQUOTES, ConstantStrings.DoubleQuote) : string.Empty;
using (ClientContext clientContext = ServiceUtility.GetClientContext(requestObject.SPAppToken, new Uri(client.Url), requestObject.RefreshToken))
{
KeywordQuery keywordQuery = new KeywordQuery(clientContext);
if (string.IsNullOrWhiteSpace(searchObject.SearchTerm))
{
searchObject.SearchTerm = ConstantStrings.Asterisk;
}
if (null != searchObject.Filters)
{
if (1 == searchObject.Filters.FilterByMe)
{
////Get logged in user alias
Users currentUserDetail = UIUtility.GetLoggedInUserDetails(clientContext);
string userTitle = currentUserDetail.Name;
searchObject.SearchTerm = string.Concat(searchObject.SearchTerm, ConstantStrings.Space, ConstantStrings.OperatorAnd, ConstantStrings.Space, ConstantStrings.OpeningBracket, SearchConstants.ManagedPropertyResponsibleAttorney, ConstantStrings.COLON, ConstantStrings.Space, ConstantStrings.DoubleQuote, userTitle, ConstantStrings.DoubleQuote, ConstantStrings.Space, ConstantStrings.OperatorOR, ConstantStrings.Space, SearchConstants.ManagedPropertyTeamMembers, ConstantStrings.COLON, ConstantStrings.Space, ConstantStrings.DoubleQuote, userTitle, ConstantStrings.DoubleQuote, ConstantStrings.Space, ConstantStrings.ClosingBracket);
}
keywordQuery = SearchHelperFunctions.FilterMatters(searchObject, keywordQuery);
}
keywordQuery = SearchHelperFunctions.KeywordQueryMetrics(client, searchObject, keywordQuery, ConstantStrings.DocumentLibraryFilterCondition, SearchConstants.ManagedPropertyIsMatter, true);
// Create a list of managed properties which are required to be present in search results
List <string> managedProperties = new List <string>();
managedProperties.Add(SearchConstants.ManagedPropertyTitle);
managedProperties.Add(SearchConstants.ManagedPropertyName);
managedProperties.Add(SearchConstants.ManagedPropertyDescription);
managedProperties.Add(SearchConstants.ManagedPropertySiteName);
managedProperties.Add(SearchConstants.ManagedPropertyLastModifiedTime);
managedProperties.Add(SearchConstants.ManagedPropertyPracticeGroup);
managedProperties.Add(SearchConstants.ManagedPropertyAreaOfLaw);
managedProperties.Add(SearchConstants.ManagedPropertySubAreaOfLaw);
managedProperties.Add(SearchConstants.ManagedPropertyMatterId);
managedProperties.Add(SearchConstants.ManagedPropertyCustomTitle);
managedProperties.Add(SearchConstants.ManagedPropertyPath);
managedProperties.Add(SearchConstants.ManagedPropertyMatterName);
managedProperties.Add(SearchConstants.ManagedPropertyOpenDate);
managedProperties.Add(SearchConstants.ManagedPropertyClientName);
managedProperties.Add(SearchConstants.ManagedPropertyBlockedUploadUsers);
managedProperties.Add(SearchConstants.ManagedPropertyResponsibleAttorney);
managedProperties.Add(SearchConstants.ManagedPropertyClientID);
managedProperties.Add(SearchConstants.ManagedPropertyMatterGuid);
//Filter on Result source to fetch only Matter Center specific results
keywordQuery.SourceId = new Guid(SearchConstants.SearchResultSourceID);
keywordQuery = SearchHelperFunctions.AssignKeywordQueryValues(keywordQuery, managedProperties);
keywordQuery.BypassResultTypes = true;
result = SearchHelperFunctions.FillResultData(clientContext, keywordQuery, searchObject, true, managedProperties);
}
}
catch (Exception exception)
{
result = Logger.LogError(exception, MethodBase.GetCurrentMethod().DeclaringType.Name, MethodBase.GetCurrentMethod().Name, ServiceConstantStrings.LogTableName);
}
}
else
{
result = string.Format(CultureInfo.InvariantCulture, ConstantStrings.ServiceResponse, string.Empty, TextConstants.MessageNoInputs);
}
return(result);
}
public string UrlExists(RequestObject requestObject, Client client, string requestedUrl, string requestedPageUrl)
{
string result = string.Empty;
if (null != requestObject && null != client && null != requestedUrl && null != requestedPageUrl && ValidationHelperFunctions.CheckRequestValidatorToken())
{
try
{
using (ClientContext clientContext = ServiceUtility.GetClientContext(requestObject.SPAppToken, new Uri(client.Url), requestObject.RefreshToken))
{
// Check if the OneNote exists
string oneNoteExists = SearchHelperFunctions.PageExists(requestedUrl, clientContext);
// Check if the Matter Landing Page exists
string matterLandingExists = SearchHelperFunctions.PageExists(requestedPageUrl, clientContext);
// Finally return the result of the two operations
result = oneNoteExists + ConstantStrings.DOLLAR + ConstantStrings.Pipe + ConstantStrings.DOLLAR + matterLandingExists;
}
}
catch (Exception exception)
{
// In case of a general exception, return false values for both cases
Logger.LogError(exception, MethodBase.GetCurrentMethod().DeclaringType.Name, MethodBase.GetCurrentMethod().Name, ServiceConstantStrings.LogTableName);
result = ConstantStrings.FALSE + ConstantStrings.DOLLAR + ConstantStrings.Pipe + ConstantStrings.DOLLAR + ConstantStrings.FALSE;
}
}
else
{
result = TextConstants.MessageNoInputs;
}
return(result);
}
public string SendToBriefcase(RequestObject requestObject, MailAttachmentDetails mailAttachmentDetails, bool doCheckOut)
{
string status = ConstantStrings.FALSE;
string result = string.Empty;
try
{
if (null != requestObject && null != mailAttachmentDetails && ValidationHelperFunctions.CheckRequestValidatorToken())
{
Dictionary <string, Stream> collectionOfAttachments = new Dictionary <string, Stream>();
Dictionary <string, string> collectionOfOriginalAttachments = new Dictionary <string, string>();
string[] allAttachmentUrl = mailAttachmentDetails.FullUrl.Split(ConstantStrings.Semicolon[0]);
ClientContext clientContext = null;
string usersMySite = string.Empty;
usersMySite = BriefcaseHelperFunction.GetPersonalURL(requestObject);
if (!usersMySite.ToUpperInvariant().Contains(ServiceConstantStrings.OneDriveNotSetupUrl.ToUpperInvariant()))
{
foreach (string attachmentUrl in allAttachmentUrl)
{
if (!string.IsNullOrWhiteSpace(attachmentUrl))
{
// Do not use 'using' to generate client context here since it will dispose the object before other functions get executed
clientContext = ServiceUtility.GetClientContext(requestObject.SPAppToken, new Uri(attachmentUrl.Split(Convert.ToChar(ConstantStrings.DOLLAR, CultureInfo.InvariantCulture))[0]), requestObject.RefreshToken);
Microsoft.SharePoint.Client.File file = clientContext.Web.GetFileByServerRelativeUrl(attachmentUrl.Split(Convert.ToChar(ConstantStrings.DOLLAR, CultureInfo.InvariantCulture))[1]);
ClientResult <System.IO.Stream> clientResultStream = file.OpenBinaryStream();
///// Load the Stream data for the file
clientContext.Load(file);
clientContext.ExecuteQuery();
Guid uniqueKey = Guid.NewGuid();
collectionOfAttachments.Add(attachmentUrl.Split(Convert.ToChar(ConstantStrings.DOLLAR, CultureInfo.InvariantCulture))[1].Substring(attachmentUrl.Split(Convert.ToChar(ConstantStrings.DOLLAR, CultureInfo.InvariantCulture))[1].LastIndexOf(Convert.ToChar(ConstantStrings.ForwardSlash, CultureInfo.InvariantCulture)) + 1) + ConstantStrings.DOLLAR + uniqueKey, clientResultStream.Value);
collectionOfOriginalAttachments.Add(attachmentUrl.Split(Convert.ToChar(ConstantStrings.DOLLAR, CultureInfo.InvariantCulture))[1].Substring(attachmentUrl.Split(Convert.ToChar(ConstantStrings.DOLLAR, CultureInfo.InvariantCulture))[1].LastIndexOf(Convert.ToChar(ConstantStrings.ForwardSlash, CultureInfo.InvariantCulture)) + 1) + ConstantStrings.DOLLAR + uniqueKey, attachmentUrl);
MailAttachmentDetails sendDocumentUrl = new MailAttachmentDetails();
sendDocumentUrl.FullUrl = attachmentUrl;
if (doCheckOut)
{
this.CheckOutDocument(requestObject, sendDocumentUrl);
}
}
}
status = BriefcaseHelperFunction.UploadtoBriefcase(requestObject, collectionOfAttachments, collectionOfOriginalAttachments, usersMySite, allAttachmentUrl, mailAttachmentDetails.IsOverwrite);
//// If error not occurred while sending documents to OneDrive
if (!status.Contains(ConstantStrings.Code) && !status.Contains(ConstantStrings.Value))
{
status = string.Format(CultureInfo.InvariantCulture, ConstantStrings.ServiceResponse, 0, status);
}
}
else
{
status = string.Format(CultureInfo.InvariantCulture, ConstantStrings.ServiceResponse, TextConstants.ErrorCodeOneDriveNotConfigured, usersMySite);
}
result = status;
}
else
{
result = string.Format(CultureInfo.InvariantCulture, ConstantStrings.ServiceResponse, 0, status);
}
}
catch (Exception exception)
{
result = Logger.LogError(exception, MethodBase.GetCurrentMethod().DeclaringType.Name, MethodBase.GetCurrentMethod().Name, ServiceConstantStrings.LogTableName);
}
return(result);
}
public string GetVersion(RequestObject requestObject, SyncDetails syncDetails)
{
string response = string.Empty;
VersionDetails versionDetails = new VersionDetails();
try
{
if (null != requestObject && null != syncDetails && ValidationHelperFunctions.CheckRequestValidatorToken())
{
versionDetails.Status = false;
ClientContext clientContext = null;
string usersMySite = BriefcaseHelperFunction.GetPersonalURL(requestObject);
if (!string.IsNullOrEmpty(usersMySite))
{
using (clientContext = ServiceUtility.GetClientContext(requestObject.SPAppToken, new Uri(usersMySite), requestObject.RefreshToken))
{
List <string> sourceURL = BriefcaseHelperFunction.CheckSourceURL(clientContext, syncDetails, 1);
if (sourceURL.Count != 0)
{
return(BriefcaseHelperFunction.GetNotSupportedMessage(sourceURL));
}
sourceURL = BriefcaseHelperFunction.CheckSourceURL(clientContext, syncDetails, 2);
List <string> relativeURLList = BriefcaseHelperFunction.CheckSourceURL(clientContext, syncDetails, 3);
versionDetails.RelativeURL = relativeURLList;
for (int iterator = 0; iterator < sourceURL.Count; iterator++)
{
string url = sourceURL[iterator];
string relativeURL = Convert.ToString(url.Split(Convert.ToChar(ConstantStrings.DOLLAR, CultureInfo.InvariantCulture))[1], CultureInfo.InvariantCulture);
using (clientContext = ServiceUtility.GetClientContext(requestObject.SPAppToken, new Uri(url.Split(Convert.ToChar(ConstantStrings.DOLLAR, CultureInfo.InvariantCulture))[0]), requestObject.RefreshToken))
{
Microsoft.SharePoint.Client.File file = clientContext.Web.GetFileByServerRelativeUrl(relativeURL);
string documentLibraryName = BriefcaseHelperFunction.getLibraryName(clientContext, file);
List docLib = clientContext.Web.Lists.GetByTitle(documentLibraryName);
clientContext.Load(docLib);
clientContext.ExecuteQuery();
versionDetails.IsMajorVersion.Add(docLib.EnableVersioning);
versionDetails.IsMinorVersion.Add(docLib.EnableMinorVersions);
versionDetails.Status = true;
if (versionDetails.IsMajorVersion[iterator] || versionDetails.IsMinorVersion[iterator])
{
versionDetails.CurrentMajorVersion.Add(Convert.ToString(file.MajorVersion, CultureInfo.InvariantCulture));
if (file.CheckOutType != CheckOutType.None)
{
if (0 == file.MinorVersion)
{
versionDetails.CurrentMinorVersion.Add(Convert.ToString(file.MinorVersion, CultureInfo.InvariantCulture));
}
else
{
int currentMinorVersion = file.MinorVersion - 1;
versionDetails.CurrentMinorVersion.Add(Convert.ToString(currentMinorVersion, CultureInfo.InvariantCulture));
}
clientContext.Load(file.CheckedOutByUser);
clientContext.ExecuteQuery();
User user = clientContext.Web.CurrentUser;
clientContext.Load(user);
clientContext.ExecuteQuery();
if (user.Title == file.CheckedOutByUser.Title)
{
versionDetails.CheckOutStatus.Add(Convert.ToString(file.CheckedOutByUser.Title, CultureInfo.InvariantCulture));
}
else
{
versionDetails.Status = false;
versionDetails.ErrorMessage = ServiceConstantStrings.AlreadyCheckOut;
}
}
else
{
versionDetails.CurrentMinorVersion.Add(Convert.ToString(file.MinorVersion, CultureInfo.InvariantCulture));
versionDetails.CheckOutStatus.Add(ConstantStrings.Space);
}
}
}
}
}
}
else
{
versionDetails.ErrorMessage = ServiceConstantStrings.UserMySiteNotPresent;
}
}
else
{
versionDetails.Status = false;
versionDetails.ErrorMessage = TextConstants.MessageNoInputs;
}
}
catch (Exception exception)
{
versionDetails.Status = false;
versionDetails.ErrorMessage += ServiceUtility.RemoveEscapeCharacter(exception.Message);
Logger.LogError(exception, MethodBase.GetCurrentMethod().DeclaringType.Name, MethodBase.GetCurrentMethod().Name, ServiceConstantStrings.LogTableName);
}
response = BriefcaseHelperFunction.GetSerializeResponse(versionDetails);
return(response);
}
public string FetchContextualHelpContent(RequestObject requestObject, Client client, string selectedPage)
{
// Basic initialization
string result = string.Empty, cacheKey = string.Empty;
string selectedSectionIDs = string.Empty;
IList <string> sectionID = new List <string>();
if (null != requestObject && null != client && null != selectedPage && !string.IsNullOrWhiteSpace(selectedPage) && ValidationHelperFunctions.CheckRequestValidatorToken())
{
List <ContextHelpData> contextHelpCollection = new List <ContextHelpData>();
try
{
using (ClientContext clientContext = ServiceUtility.GetClientContext(requestObject.SPAppToken, new Uri(client.Url), requestObject.RefreshToken))
{
string[] pageNames = ServiceConstantStrings.MatterCenterPages.Split(';');
switch (selectedPage)
{
case "1": selectedPage = pageNames[1];
break;
case "2": selectedPage = pageNames[2];
break;
case "4": selectedPage = pageNames[4];
break;
default: selectedPage = pageNames[0];
break;
}
cacheKey = string.Concat(selectedPage, ConstantStrings.LINKS_STATIC_STRING);
result = ServiceUtility.GetOrSetCachedValue(cacheKey);
if (result.Equals(ConstantStrings.FALSE))
{
//Object to store all the list items retrieved from SharePoint list
ListItemCollection contextualHelpSectionListItems;
// Get MatterCenterHelpSection list data
contextualHelpSectionListItems = Lists.GetData(clientContext, ServiceConstantStrings.MatterCenterHelpSectionListName, String.Format(CultureInfo.InvariantCulture, ServiceConstantStrings.RetrieveContextualHelpSectionsQuery, selectedPage));
//If these exists any content for contextual help flyout
if (null != contextualHelpSectionListItems && 0 < contextualHelpSectionListItems.Count)
{
SearchHelperFunctions.FetchContextualHelpContentUtility(ref result, ref selectedSectionIDs, sectionID, ref contextHelpCollection, clientContext, contextualHelpSectionListItems);
if (!ServiceUtility.CheckValueHasErrors(result))
{
ServiceUtility.GetOrSetCachedValue(cacheKey, result);
}
}
}
}
}
catch (Exception exception)
{
result = Logger.LogError(exception, MethodBase.GetCurrentMethod().DeclaringType.Name, MethodBase.GetCurrentMethod().Name, ServiceConstantStrings.LogTableName);
}
}
return(result);
}
public string[] CheckedOutDocumentByUser(RequestObject requestObject, MailAttachmentDetails mailAttachmentDetails)
{
string[] result = null;
if (null != requestObject && null != mailAttachmentDetails && ValidationHelperFunctions.CheckRequestValidatorToken())
{
string fileException;
User checkedOutByUser = null;
try
{
List <string> checkedOutByUserTitle = new List <string>();
if (null != requestObject && null != mailAttachmentDetails)
{
// full URL, relative URL
string[] allAttachmentUrl = mailAttachmentDetails.FullUrl.Split(ConstantStrings.Semicolon[0]);
ClientContext clientContext;
foreach (string attachmentUrl in allAttachmentUrl)
{
try // To continue retrieve the document status for all documents even if one of the document is not present
{
if (!string.IsNullOrWhiteSpace(attachmentUrl))
{
using (clientContext = ServiceUtility.GetClientContext(requestObject.SPAppToken, new Uri(attachmentUrl.Split(Convert.ToChar(ConstantStrings.DOLLAR, CultureInfo.InvariantCulture))[0]), requestObject.RefreshToken))
{
string relativePath = attachmentUrl.Split(Convert.ToChar(ConstantStrings.DOLLAR, CultureInfo.InvariantCulture))[1];
string[] folderPath = relativePath.Split(Convert.ToChar(ConstantStrings.ForwardSlash, CultureInfo.InvariantCulture));
bool checkExists = false;
Folder folder = clientContext.Web.GetFolderByServerRelativeUrl(relativePath.Substring(0, relativePath.Length - folderPath[folderPath.Length - 1].Length - 1));
FileCollection files = folder.Files;
clientContext.Load(folder);
clientContext.Load(files);
clientContext.ExecuteQuery();
foreach (Microsoft.SharePoint.Client.File file in files)
{
if (file.Name.ToUpperInvariant() == folderPath[folderPath.Length - 1].ToUpperInvariant())
{
checkExists = true;
break;
}
}
if (checkExists)
{
Microsoft.SharePoint.Client.File file = clientContext.Web.GetFileByServerRelativeUrl(attachmentUrl.Split(Convert.ToChar(ConstantStrings.DOLLAR, CultureInfo.InvariantCulture))[1]);
clientContext.Load(file);
clientContext.ExecuteQuery();
if (file.CheckOutType == CheckOutType.None)
{
checkedOutByUserTitle.Add(string.Empty);
}
else
{
clientContext.ExecuteQuery();
checkedOutByUser = file.CheckedOutByUser;
clientContext.Load(checkedOutByUser);
clientContext.ExecuteQuery();
checkedOutByUserTitle.Add(checkedOutByUser.Title);
}
}
else
{
checkedOutByUserTitle.Add(TextConstants.FileNotAvailableMessage);
}
}
}
}
catch (Exception exception)
{
fileException = Logger.LogError(exception, MethodBase.GetCurrentMethod().DeclaringType.Name, MethodBase.GetCurrentMethod().Name, ServiceConstantStrings.LogTableName);
checkedOutByUserTitle.Add(fileException);
}
}
}
result = checkedOutByUserTitle.ToArray();
}
catch (Exception exception)
{
fileException = Logger.LogError(exception, MethodBase.GetCurrentMethod().DeclaringType.Name, MethodBase.GetCurrentMethod().Name, ServiceConstantStrings.LogTableName);
result = new[] { fileException };
}
}
else
{
result = new[] { TextConstants.MessageNoInputs };
}
return(result);
}
public string SendToMatter(RequestObject requestObject, BriefcaseDetails[] briefcaseDetails, int versionInfo, string comments, bool retainCheckout, bool convenienceCopy)
{
CommonResponse checkInResponse = new CommonResponse();
string status = string.Empty;
try
{
if (null != requestObject && null != briefcaseDetails && ValidationHelperFunctions.CheckRequestValidatorToken())
{
ClientContext clientContext = null;
string usersMySite = BriefcaseHelperFunction.GetPersonalURL(requestObject);
if (!string.IsNullOrEmpty(usersMySite))
{
for (int iterator = 0; iterator < briefcaseDetails.Length; iterator++)
{
if (!string.IsNullOrWhiteSpace(briefcaseDetails[iterator].DocumentUrl) && !string.IsNullOrWhiteSpace(briefcaseDetails[iterator].DocumentId))
{
using (clientContext = ServiceUtility.GetClientContext(requestObject.SPAppToken, new Uri(usersMySite), requestObject.RefreshToken))
{
ClientResult <System.IO.Stream> data = Lists.GetStreamFromFile(clientContext, briefcaseDetails[iterator].DocumentUrl);
string briefcaseItemQuery = string.Format(CultureInfo.InvariantCulture, ServiceConstantStrings.SendToMatterQuery, ServiceConstantStrings.OneDriveSiteColumn, briefcaseDetails[iterator].DocumentId);
ListItemCollection listItems = Lists.GetData(clientContext, ServiceConstantStrings.OneDriveDocumentLibraryTitle, briefcaseItemQuery);
string sourceUrl = string.Empty;
foreach (var listItem in listItems)
{
sourceUrl = Convert.ToString(listItem[ServiceConstantStrings.OneDriveSiteColumn], CultureInfo.InvariantCulture);
}
if (!string.IsNullOrWhiteSpace(sourceUrl))
{
status = BriefcaseHelperFunction.UploadtoMatter(requestObject, sourceUrl, data.Value, versionInfo, comments, retainCheckout);
checkInResponse.Status.Add(Convert.ToBoolean(status.Split(ConstantStrings.Comma[0])[0], CultureInfo.InvariantCulture));
if (checkInResponse.Status[iterator])
{
checkInResponse.FileNames.Add(status.Split(ConstantStrings.Comma[0])[1]);
if (!retainCheckout)
{
if (!convenienceCopy)
{
foreach (var listitem in listItems)
{
listitem.DeleteObject();
clientContext.ExecuteQuery();
}
}
}
}
else
{
checkInResponse.ErrorMessage += ConstantStrings.Space + status.Split(ConstantStrings.Comma[0])[1];
}
}
}
}
}
}
else
{
checkInResponse.ErrorMessage = ServiceConstantStrings.UserMySiteNotPresent;
}
}
else
{
checkInResponse.Status.Add(false);
checkInResponse.ErrorMessage += ConstantStrings.Space + TextConstants.MissingParametersMessage;
}
}
catch (Exception exception)
{
Logger.LogError(exception, MethodBase.GetCurrentMethod().DeclaringType.Name, MethodBase.GetCurrentMethod().Name, ServiceConstantStrings.LogTableName);
checkInResponse.Status.Add(false);
checkInResponse.ErrorMessage += ConstantStrings.Space + ServiceUtility.RemoveEscapeCharacter(exception.Message);
}
return(BriefcaseHelperFunction.GetSerializeResponse(checkInResponse));
}
/// <summary>
/// Gets the hierarchy of terms along with the specific custom properties of each term from term store.
/// </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 async Task <IActionResult> GetTaxonomy([FromBody] TermStoreViewModel termStoreViewModel)
{
try
{
spoAuthorization.AccessToken = HttpContext.Request.Headers["Authorization"];
#region Error Checking
ErrorResponse errorResponse = null;
//if the token is not valid, immediately return no authorization error to the user
if (errorResponse != null && !errorResponse.IsTokenValid)
{
return(matterCenterServiceFunctions.ServiceResponse(errorResponse, (int)HttpStatusCode.Unauthorized));
}
ValidationHelperFunctions.ErrorSettings = errorSettings;
errorResponse = ValidationHelperFunctions.TaxonomyValidation(termStoreViewModel.Client);
if (errorResponse != null && !String.IsNullOrWhiteSpace(errorResponse.Message))
{
return(matterCenterServiceFunctions.ServiceResponse(errorResponse, (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.GeneralSettings = generalSettings;
//cacheValue = ServiceUtility.GetDataFromAzureRedisCache(key);
TaxonomyResponseVM taxonomyRepositoryVM = null;
if (String.IsNullOrEmpty(cacheValue))
{
taxonomyRepositoryVM = await taxonomyRepository.GetTaxonomyHierarchyAsync(termStoreViewModel);
if (termStoreViewModel.TermStoreDetails.TermSetName == taxonomySettings.PracticeGroupTermSetName && taxonomyRepositoryVM.TermSets != null)
{
ServiceUtility.SetDataIntoAzureRedisCache <TermSets>(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 <TermSets>(cacheValue);
if (pgTermSets == null)
{
errorResponse = new ErrorResponse()
{
Message = errorSettings.MessageNoResult,
ErrorCode = "404",
Description = "No data is present for the given passed input"
};
return(matterCenterServiceFunctions.ServiceResponse(errorResponse, (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)
{
errorResponse = new ErrorResponse()
{
Message = errorSettings.MessageNoResult,
ErrorCode = "404",
Description = "No data is present for the given passed input"
};
return(matterCenterServiceFunctions.ServiceResponse(errorResponse, (int)HttpStatusCode.NotFound));
}
return(matterCenterServiceFunctions.ServiceResponse(clientTermSets, (int)HttpStatusCode.OK));
}
}
//If all the above condition fails, return validation error object
errorResponse = new ErrorResponse()
{
Message = errorSettings.MessageNoResult,
ErrorCode = "404",
Description = "No data is present for the given passed input"
};
return(matterCenterServiceFunctions.ServiceResponse(errorResponse, (int)HttpStatusCode.NotFound));
}
catch (Exception ex)
{
customLogger.LogError(ex, MethodBase.GetCurrentMethod().DeclaringType.Name, MethodBase.GetCurrentMethod().Name, logTables.SPOLogTable);
throw;
}
}
