/// <summary>
/// method which converts userbackend entity to dto by using mapper
/// </summary>
/// <param name="userbackendentity">takes user backend entity as input</param>
/// <returns>returns user backend dto</returns>
public UserBackendDTO UserBackendEntityDTOMapper(UserBackendEntity userbackendentity)
{
//convertig entity to data transfer object using mapper
UserBackendDTO userbackenddto = DataProvider.ResponseObjectMapper <UserBackendDTO, UserBackendEntity>(userbackendentity);
Backend backenddto = DataProvider.ResponseObjectMapper <Backend, UserBackendEntity>(userbackendentity);
userbackenddto.backend = backenddto;
return(userbackenddto);
}
/// <summary>
/// method which converts userbackend dto to entity by using mapper, first maps backenddto with userbackendentity
/// </summary>
/// <param name="userbackenddto">takes user backend dto as input</param>
/// <returns>returns user backend entity</returns>
public UserBackendEntity UserBackendDTOEntityMapper(UserBackendDTO userbackenddto)
{
//converting input backend data transfer object(dto) list to userbackend entity list by using property mapper
Backend backenddto = userbackenddto.backend;
UserBackendEntity userbackendentity = DataProvider.ResponseObjectMapper <UserBackendEntity, Backend>(backenddto);
//adding missing properties like userID, partitionkey and Rowkey to entity
userbackendentity.UserID = userbackenddto.UserID;
userbackendentity.PartitionKey = string.Concat(CoreConstants.AzureTables.UserBackendPK, userbackendentity.UserID);
userbackendentity.RowKey = userbackendentity.BackendID;
return(userbackendentity);
}
/// <summary>
/// method to get all userbackends
/// </summary>
/// <param name="UserID">takes userid as input</param>
/// <returns>returns list of user backend</returns>
public IEnumerable <UserBackendDTO> GetUserAllBackends(string UserID)
{
string callerMethodName = string.Empty;
try
{
//Get Caller Method name from CallerInformation class
callerMethodName = CallerInformation.TrackCallerMethodName();
UserBackendDAL userbackenddal = new UserBackendDAL();
//calling data access layer method to get user backends
List <UserBackendEntity> alluserbackends = userbackenddal.GetUserAllBackends(UserID);
//calling data access layer method to get user backend synch
List <SynchEntity> allbackendsynch = userbackenddal.GetAllUserBackendsSynch(UserID);
List <UserBackendDTO> userbackendsdtolist = new List <UserBackendDTO>();
//check for null
if (alluserbackends != null && alluserbackends.Count > 0)
{
//converting userdevice entity to userdevice data transfer object
foreach (UserBackendEntity userbackendentity in alluserbackends)
{
UserBackendDTO userbackenddto = UserBackendEntityDTOMapper(userbackendentity);
SynchEntity synchentity = allbackendsynch.Where(m => m.RowKey.Equals(userbackendentity.BackendID)).FirstOrDefault();
//if user backend synch available then convert to dto
if (synchentity != null)
{
SynchDTO synchdto = DataProvider.ResponseObjectMapper <SynchDTO, SynchEntity>(synchentity);
userbackenddto.synch = synchdto;
}
userbackendsdtolist.Add(userbackenddto);
}
}
else
{
userbackendsdtolist = null;
}
return((IEnumerable <UserBackendDTO>)userbackendsdtolist);
}
catch (DataAccessException DALexception)
{
throw DALexception;
}
catch (Exception exception)
{
InsightLogger.Exception(exception.Message, exception, callerMethodName);
//LoggerHelper.WriteToLog(exception + " - Error in BL while retreiving userbackends : "
//+exception.ToString(), CoreConstants.Priority.High, CoreConstants.Category.Error);
throw new BusinessLogicException();
}
}
//Gets the Avaliable backend deatils returned by Personalization API
public async Task <List <UserBackendDTO> > BackEndInfo()
{
//creates list Backend model object
List <UserBackendDTO> backends = new List <UserBackendDTO>();
try
{
//Api Controller object initialization
APIController apiControllerObj = new APIController();
//Gets the List of backends returned by the Personalization API
string strbackEndApp = await apiControllerObj.Getbackendapplications();
if (!string.IsNullOrEmpty(strbackEndApp))
{
//Deseralize the result returned by the API
BackendJsonData backendjsonResponse = JsonConvert.DeserializeObject <BackendJsonData>(strbackEndApp);
//Checks whether the JSON response is not null
if (backendjsonResponse != null)
{
//Iterate backend json format result and bind to Model
foreach (BackendJsonResult backendid in backendjsonResponse.Results)
{
//Create UserBackendDTO Model object
UserBackendDTO BackendObj = new UserBackendDTO();
BackendObj.backend = new BackendDTO();
//Get Backend id
BackendObj.backend.BackendID = backendid.BackendID;
BackendObj.backend.BackendName = backendid.BackendName;
//Adding the Model object to the list
backends.Add(BackendObj);
}
}
}
//Return list of backends
return(backends);
}
catch (Exception exception)
{
LoggerHelper.WriteToLog(exception + " - Error while creating client context : "
+ exception.ToString(), CoreConstants.Priority.High, CoreConstants.Category.Error);
throw new DataAccessException("Error in BackEndInfo");
}
}
/// <summary>
/// method to get single userbackend
/// </summary>
/// <param name="userID">takes userid as input</param>
/// <param name="userBackendID">takes user backend id as input</param>
/// <returns>returns user backend with id associated to user in the form of personalization response</returns>
public PersonalizationResponseDTO <UserBackendDTO> GetUserBackend(string userID, string userBackendID)
{
string callerMethodName = string.Empty;
try
{
//Get Caller Method name from CallerInformation class
callerMethodName = CallerInformation.TrackCallerMethodName();
UserBackendDAL userbackenddal = new UserBackendDAL();
UserBackendEntity userbackendentity = userbackenddal.GetUserBackend(userID, userBackendID);
SynchEntity synch = userbackenddal.GetBackendSynch(userID, userBackendID);
//converting userbackend entity to Response data transfer object
var ResponseUserBackend = new PersonalizationResponseDTO <UserBackendDTO>();
///check for null
if (userbackendentity != null)
{
UserBackendDTO userbackenddto = UserBackendEntityDTOMapper(userbackendentity);
//adding synch to user backend
if (synch != null)
{
SynchDTO synchdto = DataProvider.ResponseObjectMapper <SynchDTO, SynchEntity>(synch);
userbackenddto.synch = synchdto;
}
ResponseUserBackend.result = userbackenddto;
}
else
{
ResponseUserBackend.result = null;
}
return(ResponseUserBackend);
}
catch (DataAccessException DALexception)
{
throw DALexception;
}
catch (Exception exception)
{
InsightLogger.Exception(exception.Message, exception, callerMethodName);
//LoggerHelper.WriteToLog(exception + " - Error in BL while retreiving single userbackend : "
//+exception.ToString(), CoreConstants.Priority.High, CoreConstants.Category.Error);
throw new BusinessLogicException();
}
}
public async Task <UserBackendDTO> GetBackendDTO(int id)
{
var user = await _repository.GetByIdAsync(id);
var userInformations = user.UserInformation;
var userBackendDTO = new UserBackendDTO();
userBackendDTO.Id = user.Id;
userBackendDTO.Name = userInformations.Name;
userBackendDTO.Login = user.Login;
userBackendDTO.Password = user.Password;
userBackendDTO.Email = userInformations.Email;
userBackendDTO.IdRealm = userInformations.Realm.Id;
userBackendDTO.IdRegion = userInformations.Region.Id;
userBackendDTO.IdBusinessLevel = userInformations.BusinessLevel.Id;
return(userBackendDTO);
}
//Gets the user backend deatils returned by Personalization API
public async Task <UserDTO> Getuserdetails()
{
//creates list Backend model object
List <UserBackendDTO> userBackend = new List <UserBackendDTO>();
//creates list Device model object
List <UserDeviceDTO> UserDevicedetails = new List <UserDeviceDTO>();
try
{
//Api Controller object initialization
APIController apiControllerObj = new APIController();
//NewUser model object initialization
UserDTO userdetails = new UserDTO();
//Gets the user details returned by Personalization API
string strUserExisits = await apiControllerObj.Getuserinfo(userid);
if (!string.IsNullOrEmpty(strUserExisits))
{
//Deseralize the result returned by the API
NewuserJsonData newuserjsonResponse = JsonConvert.DeserializeObject <NewuserJsonData>(strUserExisits);
//Checks whether the JSON response is not null
if (newuserjsonResponse.userResults != null)
{
UserBackendJsonData userBackendjsonResponse = JsonConvert.DeserializeObject <UserBackendJsonData>(strUserExisits);
UserDeviceJsonData userDevicejsonResponse = JsonConvert.DeserializeObject <UserDeviceJsonData>(strUserExisits);
//Checks whether the JSON response is not null
if (newuserjsonResponse != null)
{
//Getting All updated user info
userdetails.UserID = newuserjsonResponse.userResults.UserID;
userdetails.FirstName = newuserjsonResponse.userResults.FirstName;
userdetails.LastName = newuserjsonResponse.userResults.LastName;
userdetails.Fullname = newuserjsonResponse.userResults.Fullname;
userdetails.Email = newuserjsonResponse.userResults.Email;
userdetails.Domain = newuserjsonResponse.userResults.Domain;
userdetails.DeviceName = newuserjsonResponse.userResults.DeviceName;
userdetails.DeviceOS = newuserjsonResponse.userResults.DeviceOS;
}
//Checks whether the JSON response is not null
if (userBackendjsonResponse != null && userBackendjsonResponse.userBackendResults.userBackenddetails != null)
{
//Iterate user backend json format result and bind to Model
foreach (userBackenddetails UserbackendInfo in userBackendjsonResponse.userBackendResults.userBackenddetails)
{
//Create Model object
UserBackendDTO BackendObj = new UserBackendDTO();
BackendObj.UserID = UserbackendInfo.UserID;
BackendObj.backend = new BackendDTO();
//setting the properties of Model
BackendObj.backend.BackendID = UserbackendInfo.userBackend.BackendID;
BackendObj.backend.BackendName = UserbackendInfo.userBackend.BackendName;
BackendObj.backend.DefaultUpdateFrequency = UserbackendInfo.userBackend.DefaultUpdateFrequency;
BackendObj.backend.AverageAllRequestsLatency = UserbackendInfo.userBackend.AverageAllRequestsLatency;
BackendObj.backend.AverageAllRequestsSize = UserbackendInfo.userBackend.AverageAllRequestsSize;
BackendObj.backend.AverageRequestLatency = UserbackendInfo.userBackend.AverageRequestLatency;
BackendObj.backend.AverageRequestSize = UserbackendInfo.userBackend.AverageRequestSize;
BackendObj.backend.ExpectedLatency = UserbackendInfo.userBackend.ExpectedLatency;
DateTime?expdate = UserbackendInfo.userBackend.ExpectedUpdate;
if (expdate != null)
{
BackendObj.backend.ExpectedUpdate = expdate.Value;
}
BackendObj.backend.LastAllRequestsLatency = UserbackendInfo.userBackend.LastAllRequestsLatency;
BackendObj.backend.LastAllRequestsSize = UserbackendInfo.userBackend.LastAllRequestsSize;
BackendObj.backend.LastRequestLatency = UserbackendInfo.userBackend.LastRequestLatency;
BackendObj.backend.LastRequestSize = UserbackendInfo.userBackend.LastRequestSize;
DateTime?lstdate = UserbackendInfo.userBackend.LastUpdate;
if (lstdate != null)
{
BackendObj.backend.LastUpdate = lstdate.Value;
}
BackendObj.backend.OpenApprovals = UserbackendInfo.userBackend.OpenApprovals;
BackendObj.backend.OpenRequests = UserbackendInfo.userBackend.OpenRequests;
BackendObj.backend.TotalBatchRequestsCount = UserbackendInfo.userBackend.TotalBatchRequestsCount;
BackendObj.backend.TotalRequestsCount = UserbackendInfo.userBackend.TotalRequestsCount;
BackendObj.backend.UpdateTriggered = UserbackendInfo.userBackend.UpdateTriggered;
BackendObj.backend.UrgentApprovals = UserbackendInfo.userBackend.UrgentApprovals;
// BackendObj.backend.MissingConfirmationsLimit = UserbackendInfo.userBackend.MissingConfirmationsLimit;
//Adding the Model object to the list
userBackend.Add(BackendObj);
userdetails.userbackends = userBackend;
}
}
//Checks whether the JSON response is not null
if (userDevicejsonResponse != null && userDevicejsonResponse.userDevicesResults.userDevicedetails != null)
{
//Iterate user devices json format result and bind to Model
foreach (userDevicedetails userDeviceInfo in userDevicejsonResponse.userDevicesResults.userDevicedetails)
{
//Create Model object
UserDeviceDTO deviceObj = new UserDeviceDTO();
// Get user device details
deviceObj.UserID = userDeviceInfo.UserID;
deviceObj.device = new DeviceDTO();
deviceObj.device.DeviceID = userDeviceInfo.userDevices.DeviceID;
deviceObj.device.DeviceName = userDeviceInfo.userDevices.DeviceName;
deviceObj.device.DeviceBrand = userDeviceInfo.userDevices.DeviceBrand;
deviceObj.device.DeviceModel = userDeviceInfo.userDevices.DeviceModel;
deviceObj.device.maxSynchReplySize = userDeviceInfo.userDevices.maxSynchReplySize;
// Add details to new model
UserDevicedetails.Add(deviceObj);
userdetails.userdevices = UserDevicedetails;
}
}
}
}
//Return user details as list object
return(userdetails);
}
catch (Exception exception)
{
LoggerHelper.WriteToLog(exception + " - Error while creating client context : "
+ exception.ToString(), CoreConstants.Priority.High, CoreConstants.Category.Error);
throw new DataAccessException("Error in Getuserdetails");
}
}
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();
}
}
