public async Task <IActionResult> GetOrderDetailsHistory([FromHeader(Name = "Grid-Authorization-Token")] string token, [FromRoute] int orderID)
{
try
{
if (string.IsNullOrEmpty(token))
{
return(Ok(new OperationResponse
{
HasSucceeded = false,
IsDomainValidationErrors = true,
Message = EnumExtensions.GetDescription(CommonErrors.TokenEmpty)
}));
}
AdminUsersDataAccess _adminUsersDataAccess = new AdminUsersDataAccess(_iconfiguration);
DatabaseResponse tokenAuthResponse = await _adminUsersDataAccess.AuthenticateAdminUserToken(token);
if (tokenAuthResponse.ResponseCode == (int)DbReturnValue.AuthSuccess)
{
if (!((AuthTokenResponse)tokenAuthResponse.Results).IsExpired)
{
if (!ModelState.IsValid)
{
return(StatusCode((int)HttpStatusCode.OK,
new OperationResponse
{
HasSucceeded = false,
IsDomainValidationErrors = true,
Message = string.Join("; ", ModelState.Values
.SelectMany(x => x.Errors)
.Select(x => x.ErrorMessage))
}));
}
var orderList = await _adminOrderDataAccess.GetNRICOrderDetailsHistory(orderID);
if (orderList == null || orderList.Count == 0)
{
return(Ok(new ServerResponse
{
HasSucceeded = false,
Message = EnumExtensions.GetDescription(DbReturnValue.NotExists)
}));
}
else
{
return(Ok(new ServerResponse
{
HasSucceeded = true,
Message = StatusMessages.SuccessMessage,
Result = orderList
}));
}
}
else
{
//Token expired
LogInfo.Warning(EnumExtensions.GetDescription(CommonErrors.ExpiredToken));
return(Ok(new OperationResponse
{
HasSucceeded = false,
Message = EnumExtensions.GetDescription(DbReturnValue.TokenExpired),
IsDomainValidationErrors = true
}));
}
}
else
{
// token auth failure
LogInfo.Warning(EnumExtensions.GetDescription(DbReturnValue.TokenAuthFailed));
return(Ok(new OperationResponse
{
HasSucceeded = false,
Message = EnumExtensions.GetDescription(DbReturnValue.TokenAuthFailed),
IsDomainValidationErrors = false
}));
}
}
catch (Exception ex)
{
LogInfo.Error(new ExceptionHelper().GetLogString(ex, ErrorLevel.Critical));
return(Ok(new OperationResponse
{
HasSucceeded = false,
Message = StatusMessages.ServerError,
IsDomainValidationErrors = false
}));
}
}
public async Task <IActionResult> UpdateNRICDetails([FromHeader(Name = "Grid-Authorization-Token")] string token, [FromForm] NRICDetails request)
{
try
{
if (string.IsNullOrEmpty(token))
{
return(Ok(new OperationResponse
{
HasSucceeded = false,
IsDomainValidationErrors = true,
Message = EnumExtensions.GetDescription(CommonErrors.TokenEmpty)
}));
}
AdminUsersDataAccess _adminUsersDataAccess = new AdminUsersDataAccess(_iconfiguration);
DatabaseResponse tokenAuthResponse = await _adminUsersDataAccess.AuthenticateAdminUserToken(token);
if (tokenAuthResponse.ResponseCode == (int)DbReturnValue.AuthSuccess)
{
if (!((AuthTokenResponse)tokenAuthResponse.Results).IsExpired)
{
if (!ModelState.IsValid)
{
return(StatusCode((int)HttpStatusCode.OK,
new OperationResponse
{
HasSucceeded = false,
IsDomainValidationErrors = true,
Message = string.Join("; ", ModelState.Values
.SelectMany(x => x.Errors)
.Select(x => x.ErrorMessage))
}));
}
if (!string.IsNullOrEmpty(request.IdentityCardNumber))
{
EmailValidationHelper _helper = new EmailValidationHelper();
if (!_helper.NRICValidation(null, request.IdentityCardNumber, out string _warningmsg))
{
LogInfo.Warning("NRIC Validation with type: " + _warningmsg);
return(Ok(new OperationResponse
{
HasSucceeded = false,
Message = "Document details are invalid",
IsDomainValidationErrors = false
}));
}
}
int deliveryStatusNumber = request.IDVerificationStatus;
var authToken = (AuthTokenResponse)tokenAuthResponse.Results;
MiscHelper configHelper = new MiscHelper();
CommonDataAccess _commonDataAccess = new CommonDataAccess(_iconfiguration);
NRICDetailsRequest personalDetails = new NRICDetailsRequest
{
OrderID = request.OrderID,
IdentityCardNumber = request.IdentityCardNumber,
IdentityCardType = request.IdentityCardType,
Nationality = request.Nationality,
NameInNRIC = request.NameInNRIC,
DOB = request.DOB,
Expiry = request.Expiry,
Remarks = request.Remarks,
IDVerificationStatus = request.IDVerificationStatus,
};
if (request.FrontImage != null || request.BackImage != null)
{
string IDCardNumberForImage = string.Empty;
DatabaseResponse awsConfigResponse = await _commonDataAccess.GetConfiguration(ConfiType.AWS.ToString());
if (awsConfigResponse != null && awsConfigResponse.ResponseCode == (int)DbReturnValue.RecordExists)
{
GridAWSS3Config awsConfig = configHelper.GetGridAwsConfig((List <Dictionary <string, string> >)awsConfigResponse.Results);
// Check for IdentityCardNumber
//Start
if (string.IsNullOrEmpty(request.IdentityCardNumber))
{
var orderDetailsForIDCard = await _commonDataAccess.GetOrderDetails(request.OrderID);
IDCardNumberForImage = orderDetailsForIDCard.IdentityCardNumber;
}
else
{
IDCardNumberForImage = request.IdentityCardNumber;
}
//End
AmazonS3 s3Helper = new AmazonS3(awsConfig);
if (request.FrontImage != null)
{
string fileNameFront = IDCardNumberForImage.Substring(1, IDCardNumberForImage.Length - 2) +
"_Front_" + DateTime.Now.ToString("yyMMddhhmmss") + Path.GetExtension(request.FrontImage.FileName); //Grid_IDNUMBER_yyyymmddhhmmss.extension
UploadResponse s3UploadResponse = await s3Helper.UploadFile(request.FrontImage, fileNameFront);
if (s3UploadResponse.HasSucceed)
{
personalDetails.FrontImage = awsConfig.AWSEndPoint + s3UploadResponse.FileName;
}
else
{
LogInfo.Warning(EnumExtensions.GetDescription(CommonErrors.S3UploadFailed));
}
}
if (request.BackImage != null)
{
string fileNameBack = IDCardNumberForImage.Substring(1, IDCardNumberForImage.Length - 2) + "_Back_" + DateTime.Now.ToString("yyMMddhhmmss")
+ Path.GetExtension(request.BackImage.FileName); //Grid_IDNUMBER_yyyymmddhhmmss.extension
UploadResponse s3UploadResponse = await s3Helper.UploadFile(request.BackImage, fileNameBack);
if (s3UploadResponse.HasSucceed)
{
personalDetails.BackImage = awsConfig.AWSEndPoint + s3UploadResponse.FileName;
}
else
{
LogInfo.Warning(EnumExtensions.GetDescription(CommonErrors.S3UploadFailed));
}
}
}
else
{
// unable to get aws config
LogInfo.Warning(EnumExtensions.GetDescription(CommonErrors.FailedToGetConfiguration));
}
}
var returnResponse = await _commonDataAccess.UpdateNRICDetails(authToken.CustomerID, deliveryStatusNumber, personalDetails);
if (returnResponse.ResponseCode == (int)DbReturnValue.UpdateSuccessSendEmail)
{
var emailDetails = (EmailResponse)returnResponse.Results;
DatabaseResponse configResponse = new DatabaseResponse();
DatabaseResponse tokenCreationResponse = new DatabaseResponse();
string finalURL = string.Empty;
// Fetch the URL
if (emailDetails.VerificationStatus == 2) // Rejected then token
{
configResponse = ConfigHelper.GetValueByKey(ConfigKeys.NRICReUploadLink.GetDescription(), _iconfiguration);
tokenCreationResponse = await _adminOrderDataAccess.CreateTokenForVerificationRequests(request.OrderID);
var tokenCreation = (VerificationRequestResponse)tokenCreationResponse.Results;
finalURL = configResponse.Results.ToString() + tokenCreation.RequestToken;
}
else
{
var result = await _commonDataAccess.UpdateTokenForVerificationRequests(request.OrderID);
}
//Sending message start
// Send email to customer email ConfigDataAccess _configAccess = new ConfigDataAccess(_iconfiguration);
DatabaseResponse registrationResponse = await _adminOrderDataAccess.GetEmailNotificationTemplate(emailDetails.VerificationStatus == 2?NotificationEvent.ICValidationReject.GetDescription() : NotificationEvent.ICValidationChange.GetDescription());
string[] changelog = emailDetails.ChangeLog.Split(";");
string finallog = "";
foreach (string log in changelog)
{
if (!string.IsNullOrWhiteSpace(log))
{
finallog = finallog + "• " + log.Trim() + "<br/>";
}
}
var notificationMessage = MessageHelper.GetMessage(emailDetails.Email, emailDetails.Name, emailDetails.VerificationStatus == 2 ? NotificationEvent.ICValidationReject.GetDescription() : NotificationEvent.ICValidationChange.GetDescription(),
((EmailTemplate)registrationResponse.Results).TemplateName,
_iconfiguration, string.IsNullOrWhiteSpace(finalURL) ? "-" : finalURL, string.IsNullOrWhiteSpace(emailDetails.Remark) ? "-" : emailDetails.Remark.Replace(";", "<br />"), string.IsNullOrWhiteSpace(emailDetails.ChangeLog) ? "-" : finallog);
var notificationResponse = await _adminOrderDataAccess.GetConfiguration(ConfiType.Notification.ToString());
MiscHelper parser = new MiscHelper();
var notificationConfig = parser.GetNotificationConfig((List <Dictionary <string, string> >)notificationResponse.Results);
Publisher customerNotificationPublisher = new Publisher(_iconfiguration, notificationConfig.SNSTopic);
await customerNotificationPublisher.PublishAsync(notificationMessage);
try
{
DatabaseResponse notificationLogResponse = await _adminOrderDataAccess.CreateEMailNotificationLogForDevPurpose(
new NotificationLogForDevPurpose
{
EventType = NotificationEvent.OrderSuccess.ToString(),
Message = JsonConvert.SerializeObject(notificationMessage)
});
}
catch (Exception ex)
{
LogInfo.Error(new ExceptionHelper().GetLogString(ex, ErrorLevel.Critical));
}
//Sending message Stop
return(Ok(new ServerResponse
{
HasSucceeded = true,
Message = StatusMessages.SuccessMessage,
Result = null
}));
}
else if (returnResponse.ResponseCode == (int)DbReturnValue.UpdateSuccess)
{
var emailDetails = (EmailResponse)returnResponse.Results;
DatabaseResponse configResponse = new DatabaseResponse();
DatabaseResponse tokenCreationResponse = new DatabaseResponse();
string finalURL = string.Empty;
if (emailDetails.VerificationStatus == 2) // Rejected then token
{
configResponse = ConfigHelper.GetValueByKey(ConfigKeys.NRICReUploadLink.GetDescription(), _iconfiguration);
tokenCreationResponse = await _adminOrderDataAccess.CreateTokenForVerificationRequests(request.OrderID);
var tokenCreation = (VerificationRequestResponse)tokenCreationResponse.Results;
finalURL = configResponse.Results.ToString() + tokenCreation.RequestToken;
DatabaseResponse registrationResponse = await _adminOrderDataAccess.GetEmailNotificationTemplate(NotificationEvent.ICValidationReject.GetDescription());
var notificationMessage = MessageHelper.GetMessage(emailDetails.Email, emailDetails.Name, NotificationEvent.ICValidationReject.GetDescription(),
((EmailTemplate)registrationResponse.Results).TemplateName,
_iconfiguration, string.IsNullOrWhiteSpace(finalURL) ? "-" : finalURL, string.IsNullOrWhiteSpace(emailDetails.Remark) ? "-" : emailDetails.Remark.Replace(";", "<br />"), string.IsNullOrWhiteSpace(emailDetails.ChangeLog) ? "-" : emailDetails.ChangeLog);
var notificationResponse = await _adminOrderDataAccess.GetConfiguration(ConfiType.Notification.ToString());
MiscHelper parser = new MiscHelper();
var notificationConfig = parser.GetNotificationConfig((List <Dictionary <string, string> >)notificationResponse.Results);
Publisher customerNotificationPublisher = new Publisher(_iconfiguration, notificationConfig.SNSTopic);
await customerNotificationPublisher.PublishAsync(notificationMessage);
try
{
DatabaseResponse notificationLogResponse = await _adminOrderDataAccess.CreateEMailNotificationLogForDevPurpose(
new NotificationLogForDevPurpose
{
EventType = NotificationEvent.OrderSuccess.ToString(),
Message = JsonConvert.SerializeObject(notificationMessage)
});
}
catch (Exception ex)
{
LogInfo.Error(new ExceptionHelper().GetLogString(ex, ErrorLevel.Critical));
}
}
else
{
var result = await _commonDataAccess.UpdateTokenForVerificationRequests(request.OrderID);
}
//Sending message start
// Send email to customer email ConfigDataAccess _configAccess = new ConfigDataAccess(_iconfiguration);
return(Ok(new ServerResponse
{
HasSucceeded = true,
Message = StatusMessages.SuccessMessage,
Result = null
}));
}
else
{
LogInfo.Error("UpdateNRICDetails failed for " + request.OrderID + " Order Id " + DbReturnValue.UpdationFailed);
return(Ok(new OperationResponse
{
HasSucceeded = false,
Message = EnumExtensions.GetDescription(DbReturnValue.UpdationFailed),
IsDomainValidationErrors = false
}));
}
}
else
{
//Token expired
LogInfo.Warning(EnumExtensions.GetDescription(CommonErrors.ExpiredToken));
return(Ok(new OperationResponse
{
HasSucceeded = false,
Message = EnumExtensions.GetDescription(DbReturnValue.TokenExpired),
IsDomainValidationErrors = true
}));
}
}
else
{
// token auth failure
LogInfo.Warning(EnumExtensions.GetDescription(DbReturnValue.TokenAuthFailed));
return(Ok(new OperationResponse
{
HasSucceeded = false,
Message = EnumExtensions.GetDescription(DbReturnValue.TokenAuthFailed),
IsDomainValidationErrors = false
}));
}
}
catch (Exception ex)
{
LogInfo.Error(new ExceptionHelper().GetLogString(ex, ErrorLevel.Critical));
return(Ok(new OperationResponse
{
HasSucceeded = false,
Message = StatusMessages.ServerError,
IsDomainValidationErrors = false
}));
}
}
public async Task <IActionResult> GetOrdersList([FromHeader(Name = "Grid-Authorization-Token")] string token, string deliveryStatus, DateTime?fromDate, DateTime?toDate)
{
try
{
if (string.IsNullOrEmpty(token))
{
return(Ok(new OperationResponse
{
HasSucceeded = false,
IsDomainValidationErrors = true,
Message = EnumExtensions.GetDescription(CommonErrors.TokenEmpty)
}));
}
AdminUsersDataAccess _adminUsersDataAccess = new AdminUsersDataAccess(_iconfiguration);
DatabaseResponse tokenAuthResponse = await _adminUsersDataAccess.AuthenticateAdminUserToken(token);
if (tokenAuthResponse.ResponseCode == (int)DbReturnValue.AuthSuccess)
{
if (!((AuthTokenResponse)tokenAuthResponse.Results).IsExpired)
{
if (!ModelState.IsValid)
{
return(StatusCode((int)HttpStatusCode.OK,
new OperationResponse
{
HasSucceeded = false,
IsDomainValidationErrors = true,
Message = string.Join("; ", ModelState.Values
.SelectMany(x => x.Errors)
.Select(x => x.ErrorMessage))
}));
}
int?deliveryStatusNumber = null;
if (!string.IsNullOrWhiteSpace(deliveryStatus))
{
if (deliveryStatus.Trim().ToLower() == IDVerificationStatus.PendingVerification.GetDescription().Trim().ToLower())
{
deliveryStatusNumber = 0;
}
else if (deliveryStatus.Trim().ToLower() == IDVerificationStatus.AcceptedVerification.GetDescription().Trim().ToLower())
{
deliveryStatusNumber = 1;
}
else if (deliveryStatus.Trim().ToLower() == IDVerificationStatus.RejectedVerification.GetDescription().Trim().ToLower())
{
deliveryStatusNumber = 2;
}
}
var orderList = await _adminOrderDataAccess.GetOrdersList(deliveryStatusNumber, fromDate, toDate);
if (orderList == null || orderList.Count == 0)
{
return(Ok(new ServerResponse
{
HasSucceeded = true,
Message = EnumExtensions.GetDescription(DbReturnValue.NotExists)
}));
}
else
{
return(Ok(new ServerResponse
{
HasSucceeded = true,
Message = StatusMessages.SuccessMessage,
Result = orderList
}));
}
}
else
{
//Token expired
LogInfo.Warning(EnumExtensions.GetDescription(CommonErrors.ExpiredToken));
return(Ok(new OperationResponse
{
HasSucceeded = false,
Message = EnumExtensions.GetDescription(DbReturnValue.TokenExpired),
IsDomainValidationErrors = true
}));
}
}
else
{
// token auth failure
LogInfo.Warning(EnumExtensions.GetDescription(DbReturnValue.TokenAuthFailed));
return(Ok(new OperationResponse
{
HasSucceeded = false,
Message = EnumExtensions.GetDescription(DbReturnValue.TokenAuthFailed),
IsDomainValidationErrors = false
}));
}
}
catch (Exception ex)
{
LogInfo.Error(new ExceptionHelper().GetLogString(ex, ErrorLevel.Critical));
return(Ok(new OperationResponse
{
HasSucceeded = false,
Message = StatusMessages.ServerError,
IsDomainValidationErrors = false
}));
}
}
public async Task <IActionResult> UpdateAdminProfile([FromHeader(Name = "Grid-Authorization-Token")] string token, [FromBody] AdminProfile adminuser)
{
try
{
if (string.IsNullOrEmpty(token))
{
return(Ok(new OperationResponse
{
HasSucceeded = false,
IsDomainValidationErrors = true,
Message = EnumExtensions.GetDescription(CommonErrors.TokenEmpty)
}));
}
AdminUsersDataAccess _adminUsersDataAccess = new AdminUsersDataAccess(_iconfiguration);
DatabaseResponse tokenAuthResponse = await _adminUsersDataAccess.AuthenticateAdminUserToken(token);
if (tokenAuthResponse.ResponseCode == (int)DbReturnValue.AuthSuccess)
{
if (!((AuthTokenResponse)tokenAuthResponse.Results).IsExpired)
{
int _AdminUserID = ((AuthTokenResponse)tokenAuthResponse.Results).CustomerID;
if (!ModelState.IsValid)
{
LogInfo.Warning(StatusMessages.DomainValidationError);
new OperationResponse
{
HasSucceeded = false,
IsDomainValidationErrors = true,
Message = string.Join("; ", ModelState.Values
.SelectMany(x => x.Errors)
.Select(x => x.ErrorMessage))
};
}
DatabaseResponse response = await _adminUsersDataAccess.UpdateAdminProfile(_AdminUserID, adminuser);
if (response.ResponseCode == ((int)DbReturnValue.EmailNotExists))
{
return(Ok(new OperationResponse
{
HasSucceeded = false,
Message = EnumExtensions.GetDescription(DbReturnValue.EmailNotExists),
IsDomainValidationErrors = true
}));
}
else
{
return(Ok(new OperationResponse
{
HasSucceeded = true,
Message = EnumExtensions.GetDescription(DbReturnValue.CreateSuccess),
IsDomainValidationErrors = false,
ReturnedObject = response.Results
}));
}
}
else
{
//Token expired
LogInfo.Warning(EnumExtensions.GetDescription(CommonErrors.ExpiredToken));
return(Ok(new OperationResponse
{
HasSucceeded = false,
Message = EnumExtensions.GetDescription(DbReturnValue.TokenExpired),
IsDomainValidationErrors = true
}));
}
}
else
{
// token auth failure
LogInfo.Warning(EnumExtensions.GetDescription(DbReturnValue.TokenAuthFailed));
return(Ok(new OperationResponse
{
HasSucceeded = false,
Message = EnumExtensions.GetDescription(DbReturnValue.TokenAuthFailed),
IsDomainValidationErrors = false
}));
}
}
catch (Exception ex)
{
LogInfo.Error(new ExceptionHelper().GetLogString(ex, ErrorLevel.Critical));
return(Ok(new OperationResponse
{
HasSucceeded = false,
Message = StatusMessages.ServerError,
IsDomainValidationErrors = false
}));
}
}
public async Task <IActionResult> GetOrderDetails([FromHeader(Name = "Grid-Authorization-Token")] string token, [FromRoute] int orderID)
{
try
{
if (string.IsNullOrEmpty(token))
{
return(Ok(new OperationResponse
{
HasSucceeded = false,
IsDomainValidationErrors = true,
Message = EnumExtensions.GetDescription(CommonErrors.TokenEmpty)
}));
}
AdminUsersDataAccess _adminUsersDataAccess = new AdminUsersDataAccess(_iconfiguration);
DatabaseResponse tokenAuthResponse = await _adminUsersDataAccess.AuthenticateAdminUserToken(token);
if (tokenAuthResponse.ResponseCode == (int)DbReturnValue.AuthSuccess)
{
if (!((AuthTokenResponse)tokenAuthResponse.Results).IsExpired)
{
if (!ModelState.IsValid)
{
return(StatusCode((int)HttpStatusCode.OK,
new OperationResponse
{
HasSucceeded = false,
IsDomainValidationErrors = true,
Message = string.Join("; ", ModelState.Values
.SelectMany(x => x.Errors)
.Select(x => x.ErrorMessage))
}));
}
CommonDataAccess commonData = new CommonDataAccess(_iconfiguration);
var orderList = await commonData.GetOrderDetails(orderID);
if (orderList == null || orderList.OrderID == 0)
{
return(Ok(new ServerResponse
{
HasSucceeded = false,
Message = EnumExtensions.GetDescription(DbReturnValue.NotExists)
}));
}
else
{
// DownloadFile
DatabaseResponse awsConfigResponse = await commonData.GetConfiguration(ConfiType.AWS.ToString());
if (awsConfigResponse != null && awsConfigResponse.ResponseCode == (int)DbReturnValue.RecordExists)
{
MiscHelper configHelper = new MiscHelper();
GridAWSS3Config awsConfig = configHelper.GetGridAwsConfig((List <Dictionary <string, string> >)awsConfigResponse.Results);
AmazonS3 s3Helper = new AmazonS3(awsConfig);
DownloadResponse FrontImageDownloadResponse = new DownloadResponse();
DownloadResponse BackImageDownloadResponse = new DownloadResponse();
if (!string.IsNullOrEmpty(orderList.DocumentURL))
{
FrontImageDownloadResponse = await s3Helper.DownloadFile(orderList.DocumentURL.Remove(0, awsConfig.AWSEndPoint.Length));
if (FrontImageDownloadResponse.HasSucceed)
{
orderList.FrontImage = FrontImageDownloadResponse.FileObject != null?configHelper.GetBase64StringFromByteArray(FrontImageDownloadResponse.FileObject, orderList.DocumentURL.Remove(0, awsConfig.AWSEndPoint.Length)) : null;
orderList.DocumentURL = "";
}
else
{
orderList.DocumentURL = "";
orderList.FrontImage = "";
}
}
if (!string.IsNullOrEmpty(orderList.DocumentBackURL))
{
BackImageDownloadResponse = await s3Helper.DownloadFile(orderList.DocumentBackURL.Remove(0, awsConfig.AWSEndPoint.Length));
if (BackImageDownloadResponse.HasSucceed)
{
orderList.BackImage = BackImageDownloadResponse.FileObject != null?configHelper.GetBase64StringFromByteArray(BackImageDownloadResponse.FileObject, orderList.DocumentBackURL.Remove(0, awsConfig.AWSEndPoint.Length)) : null;
orderList.DocumentBackURL = "";
}
else
{
orderList.DocumentBackURL = "";
orderList.BackImage = "";
}
}
return(Ok(new ServerResponse
{
HasSucceeded = true,
Message = StatusMessages.SuccessMessage,
Result = orderList
}));
}
else
{
// unable to get aws config
LogInfo.Warning(EnumExtensions.GetDescription(CommonErrors.FailedToGetConfiguration));
return(Ok(new OperationResponse
{
HasSucceeded = false,
Message = EnumExtensions.GetDescription(CommonErrors.FailedToGetConfiguration)
}));
}
}
}
else
{
//Token expired
LogInfo.Warning(EnumExtensions.GetDescription(CommonErrors.ExpiredToken));
return(Ok(new OperationResponse
{
HasSucceeded = false,
Message = EnumExtensions.GetDescription(DbReturnValue.TokenExpired),
IsDomainValidationErrors = true
}));
}
}
else
{
// token auth failure
LogInfo.Warning(EnumExtensions.GetDescription(DbReturnValue.TokenAuthFailed));
return(Ok(new OperationResponse
{
HasSucceeded = false,
Message = EnumExtensions.GetDescription(DbReturnValue.TokenAuthFailed),
IsDomainValidationErrors = false
}));
}
}
catch (Exception ex)
{
LogInfo.Error(new ExceptionHelper().GetLogString(ex, ErrorLevel.Critical));
return(Ok(new OperationResponse
{
HasSucceeded = false,
Message = StatusMessages.ServerError,
IsDomainValidationErrors = false
}));
}
}
public async Task <IActionResult> GetAdminRoles([FromHeader(Name = "Grid-Authorization-Token")] string token)
{
try
{
if (string.IsNullOrEmpty(token))
{
return(Ok(new OperationResponse
{
HasSucceeded = false,
IsDomainValidationErrors = true,
Message = EnumExtensions.GetDescription(CommonErrors.TokenEmpty)
}));
}
AdminUsersDataAccess _adminUsersDataAccess = new AdminUsersDataAccess(_iconfiguration);
DatabaseResponse tokenAuthResponse = await _adminUsersDataAccess.AuthenticateAdminUserToken(token);
if (tokenAuthResponse.ResponseCode == (int)DbReturnValue.AuthSuccess)
{
if (!((AuthTokenResponse)tokenAuthResponse.Results).IsExpired)
{
List <Roles> AdminUsersList = new List <Roles>();
AdminUsersList = await _adminUsersDataAccess.GetAdminRoles();
if (AdminUsersList == null || AdminUsersList.Count == 0)
{
LogInfo.Error(EnumExtensions.GetDescription(DbReturnValue.NotExists));
return(Ok(new ServerResponse
{
HasSucceeded = false,
Message = EnumExtensions.GetDescription(DbReturnValue.NotExists)
}));
}
else
{
return(Ok(new ServerResponse
{
HasSucceeded = true,
Message = StatusMessages.SuccessMessage,
Result = AdminUsersList
}));
}
}
else
{
//Token expired
LogInfo.Warning(EnumExtensions.GetDescription(CommonErrors.ExpiredToken));
return(Ok(new OperationResponse
{
HasSucceeded = false,
Message = EnumExtensions.GetDescription(DbReturnValue.TokenExpired),
IsDomainValidationErrors = true
}));
}
}
else
{
// token auth failure
LogInfo.Warning(EnumExtensions.GetDescription(DbReturnValue.TokenAuthFailed));
return(Ok(new OperationResponse
{
HasSucceeded = false,
Message = EnumExtensions.GetDescription(DbReturnValue.TokenAuthFailed),
IsDomainValidationErrors = false
}));
}
}
catch (Exception ex)
{
LogInfo.Error(new ExceptionHelper().GetLogString(ex, ErrorLevel.Critical));
return(Ok(new OperationResponse
{
HasSucceeded = false,
Message = StatusMessages.ServerError,
IsDomainValidationErrors = false
}));
}
}
public async Task <IActionResult> GetAdminLoginAuthentication([FromHeader(Name = "Grid-General-Token")] string Token, [FromBody] AdminUserLoginRequest userdetails)
{
try
{
if ((string.IsNullOrEmpty(userdetails.Email)) || (string.IsNullOrEmpty(userdetails.Password)))
{
LogInfo.Warning(StatusMessages.MissingRequiredFields);
return(Ok(new OperationResponse
{
HasSucceeded = false,
Message = StatusMessages.MissingRequiredFields,
IsDomainValidationErrors = true
}));
}
TokenValidationHelper tokenValidationHelper = new TokenValidationHelper();
if (!tokenValidationHelper.ValidateGenericToken(Token, _iconfiguration))
{
return(Ok(new OperationResponse
{
HasSucceeded = false,
Message = EnumExtensions.GetDescription(DbReturnValue.TokenAuthFailed),
IsDomainValidationErrors = true
}));
}
AdminUsersDataAccess _AdminUsersDataAccess = new AdminUsersDataAccess(_iconfiguration);
DatabaseResponse response = await _AdminUsersDataAccess.GetLoginAuthentication(userdetails);
if (response.ResponseCode == ((int)DbReturnValue.EmailNotExists))
{
return(Ok(new OperationResponse
{
HasSucceeded = false,
Message = EnumExtensions.GetDescription(DbReturnValue.EmailNotExists),
IsDomainValidationErrors = true
}));
}
else if (response.ResponseCode == ((int)DbReturnValue.PasswordIncorrect))
{
return(Ok(new OperationResponse
{
HasSucceeded = false,
Message = EnumExtensions.GetDescription(DbReturnValue.PasswordIncorrect),
IsDomainValidationErrors = true
}));
}
else if (response.ResponseCode == ((int)DbReturnValue.AccountDeactivated))
{
return(Ok(new OperationResponse
{
HasSucceeded = false,
Message = EnumExtensions.GetDescription(DbReturnValue.AccountDeactivated),
IsDomainValidationErrors = true
}));
}
else if (response.ResponseCode == ((int)DbReturnValue.AuthSuccess))
{
//Authentication success
var adminuser = new AdminUsers();
adminuser = (AdminUsers)response.Results;
var tokenHandler = new JwtSecurityTokenHandler();
var key = Encoding.ASCII.GetBytes("stratagile grid adminuser signin jwt hashing secret");
DatabaseResponse configResponse = ConfigHelper.GetValueByKey(ConfigKeys.CustomerTokenExpiryInDays.ToString(), _iconfiguration);
int expiryDay = 0;
if (configResponse.ResponseCode == (int)DbReturnValue.RecordExists)
{
expiryDay = int.Parse(configResponse.Results.ToString());
}
var tokenDescriptor = new SecurityTokenDescriptor
{
Subject = new ClaimsIdentity(new Claim[]
{
new Claim(ClaimTypes.Name, adminuser.AdminUserID.ToString())
}),
Expires = DateTime.Now.AddDays(expiryDay), // need to check with business needs
SigningCredentials = new SigningCredentials(new SymmetricSecurityKey(key), SecurityAlgorithms.HmacSha256Signature)
};
var token = tokenHandler.CreateToken(tokenDescriptor);
var tokenString = tokenHandler.WriteToken(token);
DatabaseResponse tokenResponse = new DatabaseResponse();
tokenResponse = await _AdminUsersDataAccess.LogAdminUserToken(adminuser.AdminUserID, tokenString);
// return basic user info (without password) and token to store client side
return(Ok(new OperationResponse
{
HasSucceeded = true,
Message = EnumExtensions.GetDescription(DbReturnValue.AuthSuccess),
ReturnedObject = new LoggedInPrinciple
{
AdminUser = adminuser,
IsAuthenticated = true,
Token = tokenString
}
}
));
}
else
{
return(Ok(new OperationResponse
{
HasSucceeded = false,
Message = EnumExtensions.GetDescription(DbReturnValue.ReasonUnknown),
IsDomainValidationErrors = true
}));
}
}
catch (Exception ex)
{
LogInfo.Error(new ExceptionHelper().GetLogString(ex, ErrorLevel.Critical));
return(Ok(new OperationResponse
{
HasSucceeded = false,
Message = StatusMessages.ServerError,
IsDomainValidationErrors = false
}));
}
}
public async Task <IActionResult> UpdateAdminAccountAccessibility([FromHeader(Name = "Grid-Authorization-Token")] string token, [FromRoute] int AdminUserID, int Status)
{
try
{
if (string.IsNullOrEmpty(token))
{
return(Ok(new OperationResponse
{
HasSucceeded = false,
IsDomainValidationErrors = true,
Message = EnumExtensions.GetDescription(CommonErrors.TokenEmpty)
}));
}
if (!(Status == 1 || Status == 0))
{
return(Ok(new OperationResponse
{
HasSucceeded = false,
IsDomainValidationErrors = true,
Message = EnumExtensions.GetDescription(CommonErrors.InvalidStatus)
}));
}
AdminUsersDataAccess _adminUsersDataAccess = new AdminUsersDataAccess(_iconfiguration);
DatabaseResponse tokenAuthResponse = await _adminUsersDataAccess.AuthenticateAdminUserToken(token);
if (tokenAuthResponse.ResponseCode == (int)DbReturnValue.AuthSuccess)
{
if (!((AuthTokenResponse)tokenAuthResponse.Results).IsExpired)
{
if (!ModelState.IsValid)
{
return(Ok(new OperationResponse
{
HasSucceeded = false,
IsDomainValidationErrors = true,
Message = string.Join("; ", ModelState.Values
.SelectMany(x => x.Errors)
.Select(x => x.ErrorMessage))
}));
}
DatabaseResponse updateAdminResponse = await _adminUsersDataAccess.UpdateAdminAccountAccessibility(token, AdminUserID, Status);
if (updateAdminResponse.ResponseCode == (int)DbReturnValue.UpdateSuccess)
{
//update success
return(Ok(new ServerResponse
{
HasSucceeded = true,
Message = Status == 0? EnumExtensions.GetDescription(CommonErrors.AccountDeactivated): EnumExtensions.GetDescription(CommonErrors.AccountActivated),
}));
}
if (updateAdminResponse.ResponseCode == (int)DbReturnValue.UpdationFailed)
{
//failed to update
return(Ok(new ServerResponse
{
HasSucceeded = false,
Message = EnumExtensions.GetDescription(CommonErrors.FailedToUpdateAccessibility),
}));
}
if (updateAdminResponse.ResponseCode == (int)DbReturnValue.AdminTokenNotExists)
{
//admin token not exists
return(Ok(new ServerResponse
{
HasSucceeded = false,
Message = EnumExtensions.GetDescription(CommonErrors.TokenNotExists),
}));
}
else
{
//admin user not exists
return(Ok(new ServerResponse
{
HasSucceeded = false,
Message = EnumExtensions.GetDescription(CommonErrors.UserNotExists),
}));
}
}
else
{
//Token expired
LogInfo.Warning(EnumExtensions.GetDescription(CommonErrors.ExpiredToken));
return(Ok(new OperationResponse
{
HasSucceeded = false,
Message = EnumExtensions.GetDescription(DbReturnValue.TokenExpired),
IsDomainValidationErrors = true
}));
}
}
else
{
// token auth failure
LogInfo.Warning(EnumExtensions.GetDescription(DbReturnValue.TokenAuthFailed));
return(Ok(new OperationResponse
{
HasSucceeded = false,
Message = EnumExtensions.GetDescription(DbReturnValue.TokenAuthFailed),
IsDomainValidationErrors = false
}));
}
}
catch (Exception ex)
{
LogInfo.Error(new ExceptionHelper().GetLogString(ex, ErrorLevel.Critical));
return(Ok(new OperationResponse
{
HasSucceeded = false,
Message = StatusMessages.ServerError,
IsDomainValidationErrors = false
}));
}
}
public async Task <IActionResult> EmailValidation([FromHeader(Name = "Grid-Authorization-Token")] string token, [FromRoute] string emailid)
{
try
{
if (string.IsNullOrEmpty(token))
{
return(Ok(new OperationResponse
{
HasSucceeded = false,
IsDomainValidationErrors = true,
Message = EnumExtensions.GetDescription(CommonErrors.TokenEmpty)
}));
}
AdminUsersDataAccess _adminUsersDataAccess = new AdminUsersDataAccess(_iconfiguration);
DatabaseResponse tokenAuthResponse = await _adminUsersDataAccess.AuthenticateAdminUserToken(token);
if (tokenAuthResponse.ResponseCode == (int)DbReturnValue.AuthSuccess)
{
if (!((AuthTokenResponse)tokenAuthResponse.Results).IsExpired)
{
if (!ModelState.IsValid)
{
LogInfo.Error(StatusMessages.DomainValidationError);
new OperationResponse
{
HasSucceeded = false,
IsDomainValidationErrors = true,
Message = string.Join("; ", ModelState.Values
.SelectMany(x => x.Errors)
.Select(x => x.ErrorMessage))
};
}
DatabaseResponse configResponseEmail = ConfigHelper.GetValue("EmailValidate", _iconfiguration);
List <Dictionary <string, string> > _result = ((List <Dictionary <string, string> >)configResponseEmail.Results);
EmailValidationHelper emailhelper = new EmailValidationHelper();
EmailConfig objEmailConfig = new EmailConfig();
objEmailConfig.key = _result.Single(x => x["key"] == "NeverbouceKey")["value"];
objEmailConfig.Email = emailid;
objEmailConfig.EmailAPIUrl = _result.Single(x => x["key"] == "Emailurl")["value"];
string configResponse = emailhelper.EmailValidation(objEmailConfig);
EmailValidationResponse _response = new EmailValidationResponse();
_response.Status = configResponse;
if (configResponse.ToLower().Trim() != "invalid")
{
_response.IsValid = true;
return(Ok(new ServerResponse
{
HasSucceeded = true,
Message = StatusMessages.ValidMessage,
Result = _response
}));
}
else
{
//Invalid email
_response.IsValid = false;
LogInfo.Error(EnumExtensions.GetDescription(CommonErrors.InvalidEmail));
return(Ok(new ServerResponse
{
HasSucceeded = true,
Message = StatusMessages.InvalidMessage,
Result = _response
}));
}
}
else
{
//Token expired
LogInfo.Warning(EnumExtensions.GetDescription(CommonErrors.ExpiredToken));
return(Ok(new OperationResponse
{
HasSucceeded = false,
Message = EnumExtensions.GetDescription(DbReturnValue.TokenExpired),
IsDomainValidationErrors = true
}));
}
}
else
{
// token auth failure
LogInfo.Warning(EnumExtensions.GetDescription(DbReturnValue.TokenAuthFailed));
return(Ok(new OperationResponse
{
HasSucceeded = false,
Message = EnumExtensions.GetDescription(DbReturnValue.TokenAuthFailed),
IsDomainValidationErrors = false
}));
}
}
catch (Exception ex)
{
LogInfo.Error(new ExceptionHelper().GetLogString(ex, ErrorLevel.Critical));
return(Ok(new OperationResponse
{
HasSucceeded = false,
Message = StatusMessages.ServerError,
IsDomainValidationErrors = false
}));
}
}
public override void OnActionExecuting(ActionExecutingContext filterContext)
{
try
{
Microsoft.Extensions.Primitives.StringValues adminToken;
if (filterContext.HttpContext.Request.Headers.ContainsKey("Grid-Authorization-Token"))
{
filterContext.HttpContext.Request.Headers.TryGetValue("Grid-Authorization-Token", out adminToken);
}
if (string.IsNullOrEmpty(adminToken))
{
filterContext.Result = new StatusCodeResult(401);
filterContext.Result = new RedirectToRouteResult(
new RouteValueDictionary {
{ "Controller", "Redirect" },
{ "Action", "TokenEmpty" }
});
}
else
{
// include token validation scenario - expiry
string per = _permission;
AdminUsersDataAccess _adminAccess = new AdminUsersDataAccess(_configuration);
DatabaseResponse tokenAuthResponse = _adminAccess.AuthenticateAdminUserTokenPermission(adminToken);
if (tokenAuthResponse.ResponseCode == (int)DbReturnValue.AuthSuccess)
{
if (((AuthTokenResponse)tokenAuthResponse.Results).IsExpired)
{
filterContext.Result = new StatusCodeResult(401);
filterContext.Result = new RedirectToRouteResult(
new RouteValueDictionary {
{ "Controller", "Redirect" },
{ "Action", "TokenExpired" }
});
}
}
else
{
filterContext.Result = new StatusCodeResult(401);
filterContext.Result = new RedirectToRouteResult(
new RouteValueDictionary {
{ "Controller", "Redirect" },
{ "Action", "InvalidToken" }
});
}
DatabaseResponse permissionResponse = _adminAccess.GetAdminUserPermissionsByToken(adminToken);
if (permissionResponse != null && permissionResponse.ResponseCode == (int)DbReturnValue.RecordExists)
{
List <string> permissions = (List <string>)permissionResponse.Results;
if (!permissions.Contains(_permission))
{
filterContext.Result = new StatusCodeResult(403);
filterContext.Result = new RedirectToRouteResult(
new RouteValueDictionary {
{ "Controller", "Redirect" },
{ "Action", "Forbidden" }
});
}
}
else if (permissionResponse.ResponseCode == (int)DbReturnValue.NotExists)
{
filterContext.Result = new StatusCodeResult(403);
filterContext.Result = new RedirectToRouteResult(
new RouteValueDictionary {
{ "Controller", "Redirect" },
{ "Action", "Forbidden" }
});
}
}
}
catch (Exception ex)
{
LogInfo.Error(new ExceptionHelper().GetLogString(ex, ErrorLevel.Critical));
}
}
