//Post call for sync api
public async Task <string> SyncAPIPostCall(string endpointUri, SynchRequestDTO request)
{
UserProfileController userProfileObj = new UserProfileController();
var result = string.Empty;
try
{
//create object of client request
using (HttpClient client = new HttpClient())
{
client.DefaultRequestHeaders.Add("Accept", "application/json;odata=verbose");
client.DefaultRequestHeaders.Add("ContentType", "application/json;odata=verbose");
client.DefaultRequestHeaders.Add("Authorization", "Bearer " + await userProfileObj.GetTokenForApplication());
//get API endpoint and format
var request1 = new HttpRequestMessage(HttpMethod.Post, endpointUri);
request1.Content = new StringContent(JsonConvert.SerializeObject(request), Encoding.UTF8, "application/json");
var result1 = client.SendAsync(request1).Result;
//if the api call returns successcode then return the result into string
if (result1.IsSuccessStatusCode)
{
result = result1.Content.ReadAsStringAsync().GetAwaiter().GetResult();
}
}
}
catch (Exception exception)
{
LoggerHelper.WriteToLog(exception, "Error While Connecting to an API." + exception.ToString());
throw new DataAccessException("Error While Connecting to an API");
}
return(result);
}
public async Task <ActionResult> ForceUpdate(SynchRequestDTO syncRequest)
{
try
{
//Assign user id to SynchRequestDTO model
syncRequest.userId = userid;
//Api Controller object initialization
APIController apiControllerObj = new APIController();
//string stApprovalrequestcount = await apiControllerObj.GetApprovalrequestcount(syncRequest, userid);
//do force update from Synch API
string forceUpdateResponse = await apiControllerObj.ForceUpdate(syncRequest, userid);
//Deseralize the result returned by the API;
// UserTaskcountJsonData userTaskPendingResponse = JsonConvert.DeserializeObject<UserTaskcountJsonData>(stApprovalPendingCount);
SynchTimeResponseDTO syncResponse = JsonConvert.DeserializeObject <SynchTimeResponseDTO>(forceUpdateResponse);
////creates list Backend model object
//List<string> userBackends = new List<string>();
//userBackends = syncRequest.parameters.filters.backends;
//List<string> userBackendName = syncRequest.parameters.filters.backendName;
////creates lists for Pending/Approval/Reject Count for json object result
//List<UserTaskcountJsonResult> userTaskPendingCount = userTaskPendingResponse.userTaskcountJsonResult;
//List<ApprovalCountDTO> approvalCountobj = new List<ApprovalCountDTO>();
// Return Json formate object and pass to UI
return(Json(syncResponse, JsonRequestBehavior.AllowGet));
}
catch (Exception exception)
{
LoggerHelper.WriteToLog(exception + " - Error while creating client context : "
+ exception.ToString(), CoreConstants.Priority.High, CoreConstants.Category.Error);
return(View("Error"));
}
}
public async Task <ActionResult> GetRequestPDF(RequestDetails requestInfo)
{
try
{
//Assign UI synch request details to SynchRequestDTO model
SynchRequestDTO syncRequest = requestInfo.syncRequest;
//Assign user id to SynchRequestDTO model
syncRequest.userId = userid;
//Api Controller object initialization
APIController apiControllerObj = new APIController();
//Get pdf uri details from Synch API
string strpdfuri = await apiControllerObj.GetPDFUri(syncRequest, requestInfo.requestID);
if (!string.IsNullOrEmpty(strpdfuri))
{
string pdfuri = JsonConvert.DeserializeObject <string>(strpdfuri);
// Return Json formate object and pass to UI
return(Json(new Uri(pdfuri), JsonRequestBehavior.AllowGet));
}
else
{
return(Json(string.Empty, JsonRequestBehavior.AllowGet));
}
}
catch (Exception exception)
{
LoggerHelper.WriteToLog(exception + " - Error while creating client context : "
+ exception.ToString(), CoreConstants.Priority.High, CoreConstants.Category.Error);
return(View("Error"));
}
}
//Async task for getting approvers list
public async Task <string> GetPDFUri(SynchRequestDTO syncData, string requestID)
{
string rspApprovers = string.Empty;
try
{
string WebApiRootURL = SettingsHelper.WebApiUrl;
if (!string.IsNullOrEmpty(WebApiRootURL))
{
//Creates the enpoint uri to be called
StringBuilder EndPointUri = new StringBuilder(WebApiRootURL);
string api = string.Format(SettingsHelper.SyncAPIPDF, requestID);
//SettingsHelper.PersonalizationAPIUser + userid + "/";
Uri spotlightEndPointUri =
new Uri(EndPointUri.Append(string.Format(api)).ToString());
Helper JsonHelperObj = new Helper();
//Gets the response returned by the Sync API
rspApprovers = await JsonHelperObj.SyncAPIPostCall(string.Format(spotlightEndPointUri.ToString()), syncData);
}
else
{
//Write the trace in db that no url exists
LoggerHelper.WriteToLog("WebApiRootURL URL is null", CoreConstants.Priority.High, CoreConstants.Category.Error);
return(null);
}
}
catch (Exception exception)
{
// logging an error if in case some exception occurs
LoggerHelper.WriteToLog(exception, "Error while fetching the most popular videos" + exception.ToString());
throw new DataAccessException("Data Access Exception:-Error while saving user info");
}
return(rspApprovers);
}
/// <summary>
/// method to check backend updated
/// </summary>
/// <param name="userbackend">takes user backend as input</param>
/// <returns>returns whether backend updated or not</returns>
public static Boolean IsBackendUpdated(UserBackendEntity userbackend, SynchRequestDTO query)
{
if (userbackend.LastUpdate != null)
{
return((!userbackend.UpdateTriggered) && (userbackend.DefaultUpdateFrequency > 0) && (!query.parameters.forceUpdate) && (userbackend.LastUpdate.Value.AddMinutes(userbackend.DefaultUpdateFrequency) > DateTime.Now));
}
else
{
return((!userbackend.UpdateTriggered) && (userbackend.DefaultUpdateFrequency > 0) && (!query.parameters.forceUpdate));
}
}
/// <summary>
/// method to caliculate extended depth
/// </summary>
/// <param name="query">takes qury as input</param>
/// <param name="userbackendslist">takes user backends as input</param>
/// <param name="maxsynchreplysize">takes maxsynch reply size as input</param>
/// <returns>returns true/false for extendeddepth</returns>
public static Boolean ExtendedDepthperAllBackends(SynchRequestDTO query, List <UserBackendEntity> userbackendslist, int maxsynchreplysize)
{
Boolean depth = (query.parameters.depth.overview || query.parameters.depth.genericInfo || query.parameters.depth.approvers);
int totalrequestsize = 0;
foreach (UserBackendEntity userbackend in userbackendslist)
{
totalrequestsize = totalrequestsize + (userbackend.AverageRequestSize * userbackend.OpenRequests);
}
return(depth && (totalrequestsize < maxsynchreplysize) || maxsynchreplysize == 0);
}
/// <summary>
/// method to filter out the requests changed/updated since the Last synch
/// </summary>
/// <param name="query">takes qury as input</param>
/// <param name="request">takes request as input</param>
/// <returns>returns whether request is changed after last synch</returns>
public static Boolean IsRequestATarget(SynchRequestDTO query, RequestEntity request, RequestSynchEntity requestsynch)
{
if (requestsynch != null)
{
return((query.parameters.filters.onlyChangedReq && request.LastUpdate != null && (request.LastUpdate > requestsynch.LastChange)) || (!query.parameters.filters.onlyChangedReq));
}
else
{
return(true);
}
}
/// <summary>
/// method to deicede only the filtered requests are sent back or all
/// </summary>
/// <param name="query">takes qury as input</param>
/// <param name="request">takes request as input</param>
/// <param name="approvalStatus">takes approvalStatus as input</param>
/// <param name="requestsynch">takes requestsynch as input</param>
/// <returns>returns whether filtered requests are sent back or all</returns>
public static Boolean IsTargetRequest(SynchRequestDTO query, RequestEntity request, ApprovalEntity approval, RequestSynchEntity requestsynch)
{
string QueryRequestStatus = query.parameters.filters.reqStatus;
string QueryApprovalStatus = query.parameters.filters.apprStatus;
string approvalStatus = null;
if (approval != null)
{
approvalStatus = approval.Status;
}
if (requestsynch != null)
{
return(((string.IsNullOrEmpty(QueryRequestStatus) && (request.Status == QueryRequestStatus)) || (!string.IsNullOrEmpty(QueryRequestStatus))) &&
((string.IsNullOrEmpty(QueryApprovalStatus) && (approvalStatus == QueryApprovalStatus)) || (!string.IsNullOrEmpty(QueryApprovalStatus))) &&
((query.parameters.filters.onlyChangedReq && request.LastUpdate != null && (request.LastUpdate > requestsynch.LastChange)) || (!query.parameters.filters.onlyChangedReq)));
}
else
{
return(((string.IsNullOrEmpty(QueryRequestStatus) && (request.Status == QueryRequestStatus)) || (!string.IsNullOrEmpty(QueryRequestStatus))) &&
((string.IsNullOrEmpty(QueryApprovalStatus) && (approvalStatus == QueryApprovalStatus)) || (!string.IsNullOrEmpty(QueryApprovalStatus))));
}
}
public async Task <ActionResult> GetRequestDetails(RequestDetails requestInfo)
{
try
{
//Assign UI synch request details to SynchRequestDTO model
SynchRequestDTO syncRequest = requestInfo.syncRequest;
//Assign user id to SynchRequestDTO model
syncRequest.userId = userid;
//Api Controller object initialization
APIController apiControllerObj = new APIController();
//Get request details from Synch API
string stApprovalrequest = await apiControllerObj.GetRequestInfo(syncRequest, requestInfo.requestID);
//Get Approval List details from Synch API
string strApproverList = await apiControllerObj.GetApprovers(syncRequest, requestInfo.requestID);
//Deseralize the result returned by the API
UserRequestJsonData userBackendjsonResponse = JsonConvert.DeserializeObject <UserRequestJsonData>(stApprovalrequest);
UserApprovalJsonData userApprovaljsonResponse = JsonConvert.DeserializeObject <UserApprovalJsonData>(strApproverList);
//creates list request details object
List <ApprovalRequestDTO> requestsDetails = new List <ApprovalRequestDTO>();
//Checks whether the JSON response is not null
if (userBackendjsonResponse != null && userApprovaljsonResponse != null)
{
//Create ApprovalRequestDTO Model object
ApprovalRequestDTO requestObj = new ApprovalRequestDTO();
//Iterate json format result and bind to Model
foreach (userBackendRequest userbackendRequestdetails in userBackendjsonResponse.userBackendRequestinfo)
{
//Create ApprovalDTO Model object
requestObj.approval = new ApprovalDTO();
//Create RequestDTO Model object
requestObj.request = new RequestDTO();
if (userbackendRequestdetails.requestDetails != null)
{
//Get Request ID from Json reuslt
requestObj.request.ID = userbackendRequestdetails.requestDetails.ID;
//Get Request Title from Json reuslt
requestObj.request.Title = userbackendRequestdetails.requestDetails.Title;
//Get Request Status from Json reuslt
requestObj.request.Status = userbackendRequestdetails.requestDetails.Status;
//Get Request Created from Json reuslt
DateTime?created = userbackendRequestdetails.requestDetails.Created;
if (created != null)
{
requestObj.request.Created = created.Value;
}
//Get Request Requester details from Json reuslt
requestObj.request.Requester = new RequesterDTO();
//Get Requester UserID from Json reuslt
if (requestObj.request.Requester.UserID == null)
{
requestObj.request.Requester.UserID = userbackendRequestdetails.requestDetails.Requester.UserID;
}
//Get Requester UserID from Json reuslt
if (requestObj.request.Requester.Name == null)
{
requestObj.request.Requester.Name = userbackendRequestdetails.requestDetails.Requester.Name;
}
//Creates list request fields object
List <FieldDTO> requestFields = new List <FieldDTO>();
//Checks whether the JSON response is not null
if (userbackendRequestdetails.requestDetails.Fields.Overview != null && userbackendRequestdetails.requestDetails.Fields.Overview.Count > 0)
{
//Iterate json format result and bind to Model
foreach (FieldDTO field in userbackendRequestdetails.requestDetails.Fields.Overview)
{
//Create FieldDTO Model object for Overview fields
FieldDTO overviewFields = new FieldDTO();
//Get Overview fields Name from Json reuslt
overviewFields.Name = field.Name;
//Get Overview fields Value from Json reuslt
overviewFields.Value = field.Value;
//Get Overview fields Group from Json reuslt
overviewFields.Group = field.Group;
//Add to FieldDTO Model object
requestFields.Add(overviewFields);
}
}
//Checks whether the JSON response is not null
if (userbackendRequestdetails.requestDetails.Fields.GenericInfo != null && userbackendRequestdetails.requestDetails.Fields.Overview.Count > 0)
{
//Iterate json format result and bind to Model
foreach (FieldDTO field in userbackendRequestdetails.requestDetails.Fields.GenericInfo)
{
//Create FieldDTO Model object for Generic fields
FieldDTO genericInfoFields = new FieldDTO();
//Get Generic fields Name/Value pair from Json reuslt
genericInfoFields.Name = field.Name;
genericInfoFields.Value = field.Value;
//Get Generic fields Group from Json reuslt
genericInfoFields.Group = field.Group;
//Add to FieldDTO Model object
requestFields.Add(genericInfoFields);
}
}
//Creates list approval list object
List <Approvers> approverList = new List <Approvers>();
//Iterate json format result and bind to Model
foreach (ApproversJson userApprovalJsondetails in userApprovaljsonResponse.userApprovalinfo)
{
//Create Approvers Model object for Approval details
Approvers userApprovaldetails = new Approvers();
//Get Approval Order info
userApprovaldetails.Order = userApprovalJsondetails.Order;
//Get Approval Order UserID
userApprovaldetails.UserID = userApprovalJsondetails.UserID;
//Get Approval Order UserName
userApprovaldetails.UserName = userApprovalJsondetails.UserName;
//Get Approval Order Status
userApprovaldetails.Status = userApprovalJsondetails.Status;
//Get Approval Order Created
userApprovaldetails.Created = userApprovalJsondetails.Created;
//Get Approval Order DueDate
userApprovaldetails.DueDate = userApprovalJsondetails.DueDate;
//Get Approval Order DecisionDate
userApprovaldetails.DecisionDate = userApprovalJsondetails.DecisionDate;
//getting Approver Comment
userApprovaldetails.Comment = userApprovalJsondetails.Comment;
//Add to Approvers Model object for Approval details
approverList.Add(userApprovaldetails);
}
//Add approval list to ApprovalRequestDTO Model object
requestObj.request.Approvers = approverList;
//Add Overview /Generic fields to ApprovalRequestDTO Model object
requestObj.request.Fields = requestFields;
}
else
{
requestObj.request = null;
requestObj.approval = null;
requestObj.retryAfter = userbackendRequestdetails.retryAfter;
}
//Add all info to ApprovalRequestDTO Model object List
requestsDetails.Add(requestObj);
}
}
// Return Json formate object and pass to UI
return(Json(requestsDetails, JsonRequestBehavior.AllowGet));
}
catch (Exception exception)
{
LoggerHelper.WriteToLog(exception + " - Error while creating client context : "
+ exception.ToString(), CoreConstants.Priority.High, CoreConstants.Category.Error);
return(View("Error"));
}
}
public async Task <ActionResult> GetBackendApprovalrequestcount(SynchRequestDTO syncRequest)
{
try
{
//SynchRequestDTO syncRequest = new SynchRequestDTO();
//Assign user id to SynchRequestDTO model
syncRequest.userId = userid;
//Api Controller object initialization
APIController apiControllerObj = new APIController();
//Get Pending approval count from Synch API
string stApprovalPendingCount = await apiControllerObj.GetApprovalcompletedcount(syncRequest, userid);
//Get approved count details from API
syncRequest.parameters.filters.apprStatus = "Approved";
string stApprovalApprovedCount = await apiControllerObj.GetApprovalcompletedcount(syncRequest, userid);
// Get Rejected count details from API
syncRequest.parameters.filters.apprStatus = "Rejected";
string stApprovalRejectedCount = await apiControllerObj.GetApprovalcompletedcount(syncRequest, userid);
//Deseralize the result returned by the API
UserBackendrequestJsonData userTaskPendingResponse = JsonConvert.DeserializeObject <UserBackendrequestJsonData>(stApprovalPendingCount);
UserBackendrequestJsonData userTaskApprovedResponse = JsonConvert.DeserializeObject <UserBackendrequestJsonData>(stApprovalApprovedCount);
UserBackendrequestJsonData userTaskRejectedResponse = JsonConvert.DeserializeObject <UserBackendrequestJsonData>(stApprovalRejectedCount);
//creates list Backend model object
List <string> userBackends = new List <string>();
userBackends = syncRequest.parameters.filters.backends;
List <string> userBackendName = syncRequest.parameters.filters.backendName;
//creates lists for Pending/Approval/Reject Count for json object result
UserBackendRequestJsonResult[] userBackendwithTaskPendingCount = userTaskPendingResponse.userBackendRequestResults;
UserBackendRequestJsonResult[] userBackendwithTaskApprovedCount = userTaskApprovedResponse.userBackendRequestResults;
UserBackendRequestJsonResult[] userBackendwithTaskRejectedCount = userTaskRejectedResponse.userBackendRequestResults;
List <ApprovalCountDTO> approvalCountobj = new List <ApprovalCountDTO>();
//Checks whether the JSON response is not null
if (userTaskPendingResponse != null && userBackends != null)
{
int i = 0;
//Iterate json format result and bind to Model
foreach (string backendID in userBackends)
{
//Create ApprovalCountDTO Model object
ApprovalCountDTO approvalCount = new ApprovalCountDTO();
//Get approval backend Id
approvalCount.BackendID = backendID;
//Get approval backend Name
approvalCount.BackendName = userBackendName[i];
//Get Pending approval count
if (userBackendwithTaskPendingCount != null)
{
UserBackendRequestJsonResult taskcountlist = userBackendwithTaskPendingCount.ToList().Find(x => x.userBackend.BackendID == backendID);
if (taskcountlist != null)
{
approvalCount.WaitingCount = taskcountlist.userTaskcountJsonResult.Count;
}
}
//Get Approved approval count
if (userBackendwithTaskApprovedCount != null)
{
UserBackendRequestJsonResult taskcountlist = userBackendwithTaskApprovedCount.ToList().Find(x => x.userBackend.BackendID == backendID);
if (taskcountlist != null)
{
approvalCount.ApprovedCount = taskcountlist.userTaskcountJsonResult.Count;
}
}
//Get Rejected approval count
if (userBackendwithTaskRejectedCount != null)
{
UserBackendRequestJsonResult taskcountlist = userBackendwithTaskRejectedCount.ToList().Find(x => x.userBackend.BackendID == backendID);
if (taskcountlist != null)
{
approvalCount.RejectedCount = taskcountlist.userTaskcountJsonResult.Count;
}
}
//Add ApprovalCountDTO Model object
approvalCountobj.Add(approvalCount);
i++;
}
}
// Return Json formate object and pass to UI
return(Json(approvalCountobj, JsonRequestBehavior.AllowGet));
}
catch (Exception exception)
{
LoggerHelper.WriteToLog(exception + " - Error while creating client context : "
+ exception.ToString(), CoreConstants.Priority.High, CoreConstants.Category.Error);
return(View("Error"));
}
}
public async Task <ActionResult> GetApprovalDetails(SynchRequestDTO syncRequest)
{
string userbackend = string.Empty;
try
{
//Assign UI synch request backends to list
List <string> backendId = syncRequest.parameters.filters.backends;
//Iterate backends and assign the each backend to userbackend string
foreach (string backend in backendId)
{
userbackend = backend;
}
//SynchRequestDTO syncRequest = new SynchRequestDTO();
syncRequest.userId = userid;
//Api Controller object initialization
APIController apiControllerObj = new APIController();
//creates list request details object for waiting
List <ApprovalRequestDTO> requestsDetails = new List <ApprovalRequestDTO>();
// Get the waiting approval status details
if (syncRequest.parameters.filters.apprStatus == "Waiting")
{
//Get request details from Synch API
string stApprovalPendingDetails = await apiControllerObj.GetUserBackendTasks(syncRequest, userid, userbackend);
//Deseralize the result returned by the API
UserBackendrequestJsonData userBackendjsonResponse = JsonConvert.DeserializeObject <UserBackendrequestJsonData>(stApprovalPendingDetails);
//Bind the Json result data to list
requestsDetails = ApprovalTasks(userBackendjsonResponse);
}
else
{
//creates list request details object for approval and reject
List <ApprovalRequestDTO> requestsRejectedDetails = new List <ApprovalRequestDTO>();
// Get the Approved approval status details
syncRequest.parameters.filters.apprStatus = "Approved";
//Get request details from Synch API
string stApprovalApprovedDetails = await apiControllerObj.GetUserBackendTasks(syncRequest, userid, userbackend);
//Deseralize the result returned by the API
UserBackendrequestJsonData userBackendjsonResponse = JsonConvert.DeserializeObject <UserBackendrequestJsonData>(stApprovalApprovedDetails);
//Bind the Json result data to list
requestsDetails = ApprovalTasks(userBackendjsonResponse);
// Get the Rejected approval status details
syncRequest.parameters.filters.apprStatus = "Rejected";
//Get request details from Synch API
string stApprovalRejectedDetails = await apiControllerObj.GetUserBackendTasks(syncRequest, userid, userbackend);
//Deseralize the result returned by the API
UserBackendrequestJsonData userBackendjsonRejectResponse = JsonConvert.DeserializeObject <UserBackendrequestJsonData>(stApprovalRejectedDetails);
//Bind the Json result data to list
requestsRejectedDetails = ApprovalTasks(userBackendjsonRejectResponse);
//Add approval and rejected details tasks
requestsDetails.AddRange(requestsRejectedDetails);
}
//sorting data for completed tasks based on decision date
if (syncRequest.parameters.filters.apprStatus != "Waiting")
{
List <ApprovalRequestDTO> sortedrequestsDetails = requestsDetails.OrderBy(o => o.approval.DecisionDate).ToList();
requestsDetails = sortedrequestsDetails;
}
// Return Json formate object and pass to UI
return(Json(requestsDetails, JsonRequestBehavior.AllowGet));
}
catch (Exception exception)
{
LoggerHelper.WriteToLog(exception + " - Error while creating client context : "
+ exception.ToString(), CoreConstants.Priority.High, CoreConstants.Category.Error);
return(View("Error"));
}
}
public UserBackendDTO AddRequsetsTasksCountToSynchResponse(List <RequestEntity> userbackendrequestslist, List <ApprovalEntity> userbackendapprovalslist, UserBackendEntity userbackend, SynchRequestDTO query, UserBackendDTO userbackenddto)
{
string callerMethodName = string.Empty;
try
{
//Get Caller Method name from CallerInformation class
callerMethodName = CallerInformation.TrackCallerMethodName();
List <ApprovalRequestDTO> approvalrequestlist = new List <ApprovalRequestDTO>();
InsightLogger.TrackEvent("SyncAPIController :: endpoint - api/synch/users/{userID}/backends, action: Loop through all requests in backend");
//loop through each request in the userbackend
foreach (RequestEntity request in userbackendrequestslist)
{
ApprovalRequestDTO approvalrequest = new ApprovalRequestDTO();
RequestDTO requestdto = new RequestDTO();
//get approval associated to request
ApprovalEntity approval = userbackendapprovalslist.Find(x => x.RequestId == request.ID);
if (approval != null)
{
ApprovalDTO approvaldto = new ApprovalDTO();
approvaldto = DataProvider.ResponseObjectMapper <ApprovalDTO, ApprovalEntity>(approval);
approvalrequest.approval = approvaldto;
userbackenddto.approvalsCount.Count = userbackenddto.approvalsCount.Count + 1;
//if request is updated
if (Rules.IsRequestUpdated(request, userbackend.DefaultUpdateFrequency))
{
InsightLogger.TrackEvent("SyncAPIController :: endpoint - api/synch/users/{userID}/backends, action: check request update, response: true");
//get request synch entity
RequestSynchEntity requestsynch = GetRequestSynch(request);
//check if requests which have changed since the last synch need to send in response or all requests.
if (Rules.IsTargetRequest(query, request, approval, requestsynch))
{
InsightLogger.TrackEvent("SyncAPIController :: endpoint - api/synch/users/{userID}/backends, action: Target request, response: true");
requestdto = DataProvider.ResponseObjectMapper <RequestDTO, RequestEntity>(request);
approvalrequest.request = requestdto;
InsightLogger.TrackEvent("SyncAPIController :: endpoint - api/synch/users/{userID}/backends, action: add request header to response, response: success");
//code here to populate extended depth
//code here to update request synch time stamp
AddUpdateRequestSynch(request, requestsynch, query.userId);
InsightLogger.TrackEvent("SyncAPIController :: endpoint - api/synch/users/{userID}/backends, action: Update request synch timestamp, response: success");
//requestsfulfilled = true;
}
}
else
{
InsightLogger.TrackEvent("SyncAPIController :: endpoint - api/synch/users/{userID}/backends, action: check request update, response: false");
//check if request update is in progress in service layer then send the latency in response
if (Rules.IsRequestUpdateInProgress(request))
{
InsightLogger.TrackEvent("SyncAPIController :: endpoint - api/synch/users/{userID}/backends, action: update in-progress, response: true");
approvalrequest.retryAfter = request.ExpectedLatency;
InsightLogger.TrackEvent("SyncAPIController :: endpoint - api/synch/users/{userID}/backends, action: Add expected request latancy to resposne as retry time, response: Success");
}
else
{
InsightLogger.TrackEvent("SyncAPIController :: endpoint - api/synch/users/{userID}/backends, action: update in-progress, response: false");
TriggerRequestUpdate(request, query.userId);
InsightLogger.TrackEvent("SyncAPIController :: endpoint - api/synch/users/{userID}/backends, action: trigger a Request update, response: success");
approvalrequest.retryAfter = Convert.ToInt32(Rules.RequestRetryTime(userbackend));
InsightLogger.TrackEvent("SyncAPIController :: endpoint - api/synch/users/{userID}/backends, action: Add request retrytime to response, response: success");
}
//requestsunfulfilled = true;
}
//add approval request to list which will be added to corresponding backend
approvalrequestlist.Add(approvalrequest);
}
}
userbackenddto.requests = approvalrequestlist;
return(userbackenddto);
}
catch (DataAccessException DALexception)
{
throw DALexception;
}
catch (Exception exception)
{
InsightLogger.Exception(exception.Message, exception, callerMethodName);
//LoggerHelper.WriteToLog(exception + " - Error in BL while adding all approvals count to response : "
//+ exception.ToString(), CoreConstants.Priority.High, CoreConstants.Category.Error);
throw new BusinessLogicException();
}
}
