public List <int> VerifyBuildingName()
{
var errors = new List <int>();
if (BuildingName == null)
{
return(errors);
}
BuildingName = BuildingName.Trim().Replace(HidroConstants.DOUBLE_SPACE, HidroConstants.WHITE_SPACE);
if (string.IsNullOrWhiteSpace(BuildingName))
{
BuildingName = null;
return(errors);
}
BuildingName = HelperProvider.CapitalizeFirstLetterOfEachWord(BuildingName);
var lenTest = new Regex(@".{1,50}");
if (!lenTest.IsMatch(BuildingName))
{
errors.Add(0);
}
var rx = new Regex(@"^[A-Za-z\d\-.,'() ]*$");
if (!rx.IsMatch(BuildingName))
{
errors.Add(1);
}
return(errors);
}
public List <int> VerifyProvince()
{
var errors = new List <int>();
if (Province == null)
{
return(errors);
}
Province = Province.Trim().Replace(HidroConstants.DOUBLE_SPACE, HidroConstants.WHITE_SPACE);
if (string.IsNullOrWhiteSpace(Province))
{
Province = null;
return(errors);
}
Province = HelperProvider.CapitalizeFirstLetterOfEachWord(Province);
var lenTest = new Regex(@".{1,40}");
if (!lenTest.IsMatch(Province))
{
errors.Add(37);
}
var rx = new Regex(@"^[A-Za-z\d ]*$");
if (!rx.IsMatch(Province))
{
errors.Add(38);
}
return(errors);
}
//Reprocess the GivenName before checking
public List <int> VerifyGivenName()
{
if (string.IsNullOrEmpty(GivenName) || string.IsNullOrWhiteSpace(GivenName))
{
return new List <int> {
14
}
}
;
GivenName = HelperProvider.CapitalizeFirstLetterOfEachWord(GivenName.Trim());
var errors = new List <int>();
var lenTest = new Regex(@".{1,50}");
if (!lenTest.IsMatch(GivenName))
{
errors.Add(15);
}
var spTest = new Regex(@"^[A-Za-z_\-.'() ]*$");
if (!spTest.IsMatch(GivenName))
{
errors.Add(16);
}
return(errors);
}
public List <int> VerifyTitle()
{
var errors = new List <int>();
if (string.IsNullOrEmpty(Title) || string.IsNullOrWhiteSpace(Title))
{
Title = null;
return(errors);
}
Title = Title.Trim().Replace(HidroConstants.DOUBLE_SPACE, HidroConstants.WHITE_SPACE);
Title = HelperProvider.CapitalizeFirstLetterOfEachWord(Title);
var lenTest = new Regex(@".{1,30}");
if (!lenTest.IsMatch(Title))
{
errors.Add(13);
}
var rx = new Regex(@"^[A-Za-z'.\- ]*$");
if (!rx.IsMatch(Title))
{
errors.Add(14);
}
return(errors);
}
public List <int> VerifyAltAddress()
{
var errors = new List <int>();
if (AlternateAddress == null)
{
return(errors);
}
AlternateAddress = AlternateAddress.Trim().Replace(HidroConstants.DOUBLE_SPACE, HidroConstants.WHITE_SPACE);
if (string.IsNullOrWhiteSpace(AlternateAddress))
{
AlternateAddress = null;
return(errors);
}
AlternateAddress = HelperProvider.CapitalizeFirstLetterOfEachWord(AlternateAddress);
var lenTest = new Regex(@".{1,50}");
if (!lenTest.IsMatch(AlternateAddress))
{
errors.Add(5);
}
var rx = new Regex(@"^[A-Za-z\d\-.,'() ]*$");
if (!rx.IsMatch(AlternateAddress))
{
errors.Add(6);
}
return(errors);
}
public List <int> VerifyCity()
{
var errors = new List <int>();
if (City == null)
{
return(errors);
}
City = City.Trim().Replace(HidroConstants.DOUBLE_SPACE, HidroConstants.WHITE_SPACE);
if (string.IsNullOrWhiteSpace(City))
{
City = null;
return(errors);
}
City = HelperProvider.CapitalizeFirstLetterOfEachWord(City);
var lenTest = new Regex(@".{1,40}");
if (!lenTest.IsMatch(City))
{
errors.Add(39);
}
var rx = new Regex(@"^[A-Za-z\d ]*$");
if (!rx.IsMatch(City))
{
errors.Add(40);
}
return(errors);
}
//Remove double-spaces and reprocess the value
public List <int> VerifyEthnicity()
{
var errors = new List <int>();
if (Ethnicity == null)
{
return(errors);
}
Ethnicity = Ethnicity.Trim().Replace(HidroConstants.DOUBLE_SPACE, HidroConstants.WHITE_SPACE);
if (string.IsNullOrEmpty(Ethnicity) || string.IsNullOrWhiteSpace(Ethnicity))
{
Ethnicity = null;
return(errors);
}
Ethnicity = HelperProvider.CapitalizeFirstLetterOfEachWord(Ethnicity);
var lenTest = new Regex(@".{1,30}");
if (!lenTest.IsMatch(Ethnicity))
{
errors.Add(2);
}
var enTest = new Regex(@"^[A-Za-z\-.' ]*$");
if (!enTest.IsMatch(Ethnicity))
{
errors.Add(3);
}
return(errors);
}
public List <int> VerifyQuarter()
{
var errors = new List <int>();
if (Quarter == null)
{
return(errors);
}
Quarter = Quarter.Trim().Replace(HidroConstants.DOUBLE_SPACE, HidroConstants.WHITE_SPACE);
if (string.IsNullOrWhiteSpace(Quarter))
{
Quarter = null;
return(errors);
}
Quarter = HelperProvider.CapitalizeFirstLetterOfEachWord(Quarter);
var lenTest = new Regex(@".{1,40}");
if (!lenTest.IsMatch(Quarter))
{
errors.Add(25);
}
var rx = new Regex(@"^[A-Za-z\d ]*$");
if (!rx.IsMatch(Quarter))
{
errors.Add(26);
}
return(errors);
}
//Remove double-spaces and reprocess the value
public List <int> VerifyCompany()
{
var errors = new List <int>();
if (Company == null)
{
return(errors);
}
Company = Company.Trim().Replace(HidroConstants.DOUBLE_SPACE, HidroConstants.WHITE_SPACE);
if (string.IsNullOrEmpty(Company) || string.IsNullOrWhiteSpace(Company))
{
Company = null;
return(errors);
}
Company = HelperProvider.CapitalizeFirstLetterOfEachWord(Company);
var lenTest = new Regex(@".{1,30}");
if (!lenTest.IsMatch(Company))
{
errors.Add(4);
}
var cpTest = new Regex(@"^[A-Za-z&,\-.'() ]*$");
if (!cpTest.IsMatch(Company))
{
errors.Add(5);
}
return(errors);
}
public List <int> VerifyGroup()
{
var errors = new List <int>();
if (Group == null)
{
return(errors);
}
Group = Group.Trim().Replace(HidroConstants.WHITE_SPACE, string.Empty);
if (string.IsNullOrWhiteSpace(Group))
{
Group = null;
return(errors);
}
if (!HelperProvider.IsNumber(Group))
{
errors.Add(21);
}
if (Group.Length > 30)
{
errors.Add(22);
}
return(errors);
}
public async Task <KeyValuePair <bool, PaymentDetailVM> > UpdatePaymentMethods(PaymentDetailVM paymentDetail)
{
_logger.LogInformation("PaymentService.UpdatePaymentMethods - Service starts.");
var dbPaymentMethod = await _dbContext.PaymentMethod.FindAsync(paymentDetail.PaymentMethod.Id);
if (dbPaymentMethod == null)
{
return(new KeyValuePair <bool, PaymentDetailVM>(false, null));
}
dbPaymentMethod.HolderName = paymentDetail.PaymentMethod.CreditCard.HolderName;
dbPaymentMethod.CardNumber = paymentDetail.PaymentMethod.CreditCard.CardNumber;
dbPaymentMethod.ExpiryDate = HelperProvider.ParseDateTimeString(paymentDetail.PaymentMethod.CreditCard.ExpiryDate, DATE_FORMATS.MONTH_YEAR.GetValue());
dbPaymentMethod.SecurityCode = paymentDetail.PaymentMethod.CreditCard.SecurityCode;
dbPaymentMethod.CardAddedOn = DateTime.UtcNow;
dbPaymentMethod.PaypalAddress = paymentDetail.PaymentMethod.Paypal.Email;
dbPaymentMethod.PaypalAddedOn = DateTime.UtcNow;
_dbContext.PaymentMethod.Update(dbPaymentMethod);
try {
await _dbContext.SaveChangesAsync();
} catch (Exception e) {
_logger.LogError("PaymentService.UpdatePaymentMethods - Error: " + e);
return(new KeyValuePair <bool, PaymentDetailVM>(true, null));
}
return(new KeyValuePair <bool, PaymentDetailVM>(true, paymentDetail));
}
//Remove double-spaces and reprocess the value
public List <int> VerifyJobTitle()
{
var errors = new List <int>();
if (JobTitle == null)
{
return(errors);
}
JobTitle = JobTitle.Trim().Replace(HidroConstants.DOUBLE_SPACE, HidroConstants.WHITE_SPACE);
if (string.IsNullOrEmpty(JobTitle) || string.IsNullOrWhiteSpace(JobTitle))
{
JobTitle = null;
return(errors);
}
JobTitle = HelperProvider.CapitalizeFirstLetterOfEachWord(JobTitle);
var lenTest = new Regex(@".{1,30}");
if (!lenTest.IsMatch(JobTitle))
{
errors.Add(6);
}
var jTest = new Regex(@"^[A-Za-z,\-.'() ]*$");
if (!jTest.IsMatch(JobTitle))
{
errors.Add(7);
}
return(errors);
}
public async Task <JsonResult> EnableTwoFactorAuthentication(TwoFaVM twoFa)
{
_logger.LogInformation("AccountController.EnableTwoFactorAuthentication - hidrogenianId=" + twoFa.Id);
var validation = await _reCaptchaService.IsHumanRegistration(twoFa.CaptchaToken);
if (!validation.Result)
{
return(new JsonResult(validation));
}
var secretKey = HelperProvider.GenerateRandomString(12);
var saved = await _userService.SaveTwoFaSecretKeyFor(twoFa.Id, secretKey);
if (!saved.HasValue || !saved.Value)
{
return(new JsonResult(new { Result = RESULTS.FAILED, Message = "Error occurred while attempting to setup Two-Factor Authentication at the moment. Please try again." }));
}
var identity = await _accountService.GetAccountIdentity(twoFa.Id);
var tfa = new TwoFactorAuthenticator();
var authenticator = tfa.GenerateSetupCode(
HidroConstants.PROJECT_NAME, identity.Email,
secretKey, false, 200
);
twoFa.QrImageUrl = authenticator.QrCodeSetupImageUrl;
twoFa.ManualQrCode = authenticator.ManualEntryKey;
return(new JsonResult(new { Result = RESULTS.SUCCESS, Message = twoFa }));
}
public ActionResult <string> GetSTSToken()
{
HttpResultModel ret = new HttpResultModel();
ret.result = Result.SUCCESS;
try
{
string content = HelperProvider.GetRequestContent(HttpContext);
if (String.IsNullOrEmpty(content))
{
ret.result = Result.ERROR;
ret.errorCode = MainErrorModels.PARAMETER_ERROR;
ret.message = "The request body is empty.";
Log.WriteErrorLog("v2:MainController::GetSTSToken", "请求参数为空。{0}", HelperProvider.GetHeader(HttpContext));
return(JsonConvert.SerializeObject(ret));
}
var requestBody = JsonConvert.DeserializeObject <STSTokenRequestBody>(content);
ret.data = HelperProvider.GetToken(requestBody.userId, requestBody.region);
}
catch (Exception ex)
{
ret.result = Result.ERROR;
ret.errorCode = MainErrorModels.LOGIC_ERROR;
ret.message = Convert.ToString(MainErrorModels.LOGIC_ERROR);
Log.WriteErrorLog("v2::MainController::GetSTSToken", "异常：{0}", ex.Message);
}
return(JsonConvert.SerializeObject(ret));
}
public ActionResult <string> GetUserDebitRecordDetail()
{
HttpResultModel ret = new HttpResultModel();
ret.result = Result.SUCCESS;
string content = HelperProvider.GetRequestContent(HttpContext);
if (String.IsNullOrEmpty(content))
{
ret.result = Result.ERROR;
ret.errorCode = MainErrorModels.PARAMETER_ERROR;
ret.message = "The request body is empty.";
Log.WriteErrorLog("v2:DebitController::SubmitDebitRequest", "请求参数为空。{0}", HelperProvider.GetHeader(HttpContext));
return(JsonConvert.SerializeObject(ret));
}
try
{
var requestBody = JsonConvert.DeserializeObject <DebitInfoRequestBody>(content);
DebitRecordLogResponse response = new DebitRecordLogResponse();
DataProviderResultModel result = DebitProvider.GetUserDebitRecord(requestBody.debitId);
if (result.result == Result.SUCCESS)
{
response.debitInfo = result.data as DebitInfoModel;
result = DebitProvider.GetUserDebitRecordLogs(requestBody.debitId);
if (result.result == Result.SUCCESS)
{
response.logs = result.data as List <DebitRecordLogModel>;
ret.data = response;
ret.result = Result.SUCCESS;
}
else
{
ret.result = result.result;
ret.message = result.message;
}
}
else
{
ret.result = result.result;
ret.message = result.message;
}
}
catch (Exception ex)
{
ret.result = Result.ERROR;
ret.errorCode = MainErrorModels.LOGIC_ERROR;
ret.message = "The program logic error from the DebitController::GetUserDebitRecordDetail function.";
Log.WriteErrorLog("v2::DebitController::GetUserDebitRecordDetail", "异常：{0}", ex.Message);
}
return(JsonConvert.SerializeObject(ret));
}
public RuleEngine(DataContext context)
{
this.context = context;
proxyProvider = new ProxyProvider(this);
tagManager = new TagManager(this);
helperProvider = new HelperProvider(this);
ExtractCompiledAssemblyFile();
}
public override async Task OnAuthorizationAsync(AuthorizationFilterContext filterContext)
{
string path = filterContext.HttpContext.Request.QueryString.ToString();
var list = filterContext.ActionDescriptor.FilterDescriptors.Where(p => ((FilterDescriptor)p).Filter.GetType() == typeof(AllowAnonymousFilter));
if (list.Count() == 1 || path.ToLower().IndexOf("isdebug") > -1)
{
return;
}
string token = filterContext.HttpContext.Request.Headers["token"];
string userId = filterContext.HttpContext.Request.Headers["userId"];
string qudao = filterContext.HttpContext.Request.Headers["qudao"];
string version = filterContext.HttpContext.Request.Headers["version"];
string pkgName = filterContext.HttpContext.Request.Headers["pkgName"];
if (String.IsNullOrEmpty(token))
{
HttpResultModel ret = new HttpResultModel
{
result = MainErrorModels.THE_TOKEN_VALIDATION_FAILED,
message = "Token validation failed."
};
//var response = new System.Net.Http.HttpResponseMessage(System.Net.HttpStatusCode.OK);
var content = new ContentResult();
content.Content = JsonConvert.SerializeObject(ret);
content.StatusCode = 200;
filterContext.Result = content;
Log.WriteWarning("CustomActionFilter::OnActionExecuting", "{0} {1} {2} {3} version:{4}", token, userId, qudao, ret.message, version);
}
else
{
Redis redis = HelperProvider.GetRedis();
string guid = redis.StringGet(String.Format("user_guid_{0}", userId));
string ctoken = HelperProvider.MD5Encrypt32(String.Format("{0}{1}", userId, guid));
if (ctoken != token)
{
HttpResultModel ret = new HttpResultModel
{
result = MainErrorModels.THE_TOKEN_VALIDATION_FAILED,
message = "Token validation failed."
};
var content = new ContentResult();
content.Content = JsonConvert.SerializeObject(ret);
content.StatusCode = 200;
filterContext.Result = content;
Log.WriteDebugLog("CustomActionFilter::OnActionExecuting", "{0} {1} {2} {3} version:{4}", token, userId, qudao, ctoken, version);
}
}
//await base.OnAuthorizationAsync(filterContext);
}
/// <summary>
/// 获取用户的贷款记录
/// </summary>
/// <param name="userId"></param>
/// <returns></returns>
public ActionResult <string> GetUserDebitRecords()
{
HttpResultModel ret = new HttpResultModel();
ret.result = Result.SUCCESS;
string content = HelperProvider.GetRequestContent(HttpContext);
if (String.IsNullOrEmpty(content))
{
ret.result = Result.ERROR;
ret.errorCode = MainErrorModels.PARAMETER_ERROR;
ret.message = "The request body is empty.";
Log.WriteErrorLog("v2:DebitController::SubmitDebitRequest", "请求参数为空。{0}", HelperProvider.GetHeader(HttpContext));
return(JsonConvert.SerializeObject(ret));
}
try
{
var requestBody = JsonConvert.DeserializeObject <DebitRecordsRequestBody>(content);
///逻辑
DataProviderResultModel result = DebitProvider.GetUserDebitRecords(requestBody);
if (result.result == Result.SUCCESS)
{
ret.data = result.data;
}
else
{
ret.result = result.result;
ret.message = result.message;
}
}
catch (Exception ex)
{
ret.result = Result.ERROR;
ret.errorCode = MainErrorModels.LOGIC_ERROR;
ret.message = "The program logic error from the DebitController::GetUserDebitRecords function.";
Log.WriteErrorLog("v2::DebitController::GetUserDebitRecords", "UserId:{0}，异常：{1}", content, ex.Message);
}
return(JsonConvert.SerializeObject(ret));
}
public ActionResult <string> GetSTSTokenV2(int userId, string region)
{
HttpResultModel ret = new HttpResultModel();
ret.result = Result.SUCCESS;
try
{
ret.data = HelperProvider.GetToken(userId, region);
}
catch (Exception ex)
{
ret.result = Result.ERROR;
ret.errorCode = MainErrorModels.LOGIC_ERROR;
ret.message = Convert.ToString(MainErrorModels.LOGIC_ERROR);
Log.WriteErrorLog("MainController::GetSTSToken", "异常：{0}", ex.Message);
}
return(JsonConvert.SerializeObject(ret));
}
public ActionResult <string> GetUserDebitAttention()
{
HttpResultModel ret = new HttpResultModel();
ret.result = Result.SUCCESS;
try
{
string content = HelperProvider.GetRequestContent(HttpContext);
if (String.IsNullOrEmpty(content))
{
ret.result = Result.ERROR;
ret.errorCode = MainErrorModels.PARAMETER_ERROR;
ret.message = "The request body is empty.";
Log.WriteErrorLog("v2:MainController::GetUserDebitAttention", "请求参数为空。{0}", HelperProvider.GetHeader(HttpContext));
return(JsonConvert.SerializeObject(ret));
}
var requestBody = JsonConvert.DeserializeObject <UserInfoRequestBody>(content);
int iUserId = 0;
int.TryParse(requestBody.userId, out iUserId);
///逻辑
DataProviderResultModel result = DebitProvider.GetUserDebitAttention(iUserId);
if (result.result == Result.SUCCESS)
{
ret.data = result.data;
}
else
{
ret.result = result.result;
ret.message = result.message;
}
}
catch (Exception ex)
{
ret.result = Result.ERROR;
ret.errorCode = MainErrorModels.LOGIC_ERROR;
ret.message = Convert.ToString(MainErrorModels.LOGIC_ERROR);
Log.WriteErrorLog("v2::MainController::GetUserDebitAttention", "异常：{0}", ex.Message);
}
return(JsonConvert.SerializeObject(ret));
}
/// <summary>
/// 获取贷款种类
/// </summary>
/// <returns></returns>
public ActionResult <string> GetBankCodes()
{
HttpResultModel ret = new HttpResultModel();
ret.result = Result.SUCCESS;
try
{
Redis redis = HelperProvider.GetRedis();
string key = "BankCodes";
string retJson = redis.StringGet(key);
if (String.IsNullOrEmpty(retJson))
{
DataProviderResultModel result = MainInfoProvider.GetBankCodes();
if (result.result == Result.SUCCESS)
{
ret.data = result.data;
}
else
{
ret.result = Result.ERROR;
ret.errorCode = result.result;
ret.message = result.message;
}
redis.StringSet(key, JsonConvert.SerializeObject(ret), 300);
}
else
{
return(retJson);
}
}
catch (Exception ex)
{
ret.result = Result.ERROR;
ret.errorCode = MainErrorModels.LOGIC_ERROR;
ret.message = Convert.ToString(MainErrorModels.LOGIC_ERROR);
Log.WriteErrorLog("MainController::GetBankCodes", "异常：{0}", ex.Message);
}
return(JsonConvert.SerializeObject(ret));
}
/// <summary>
///
/// </summary>
/// <param name="userId"></param>
/// <param name="debitId"></param>
/// <param name="payBackDebitMoney"></param>
/// <param name="certificateUrl"></param>
/// <returns></returns>
public ActionResult <string> SubmitExtendDebitRequest(int userId, int debitId, float payBackDebitMoney, string certificateUrl = "")
{
HttpResultModel ret = new HttpResultModel();
ret.result = Result.SUCCESS;
Redis redis = HelperProvider.GetRedis();
try
{
string lockKey = "submitExtend";
if (redis.LockTake(lockKey, userId))
{
///逻辑
DataProviderResultModel result = DebitProvider.ExtendDebitRequest(userId, debitId, payBackDebitMoney, certificateUrl);
ret.result = result.result;
if (result.result != Result.SUCCESS)
{
ret.result = Result.ERROR;
ret.errorCode = result.result;
ret.message = result.message;
}
redis.LockRelease(lockKey, userId);
}
else
{
ret.result = Result.ERROR;
ret.errorCode = MainErrorModels.ALREADY_SUBMIT_REQUEST;
ret.message = "already submit request.";
}
}
catch (Exception ex)
{
ret.result = Result.ERROR;
ret.errorCode = MainErrorModels.LOGIC_ERROR;
ret.message = Convert.ToString(MainErrorModels.LOGIC_ERROR);
Log.WriteErrorLog("DebitController::SubmitExtendDebitRequest", "异常：{0}", ex.Message);
}
return(JsonConvert.SerializeObject(ret));
}
public List <int> VerifyState()
{
var errors = new List <int>();
if (State == null)
{
return new List <int> {
18
}
}
;
State = State.Trim().Replace(HidroConstants.DOUBLE_SPACE, HidroConstants.WHITE_SPACE);
if (string.IsNullOrWhiteSpace(State))
{
return new List <int> {
18
}
}
;
State = HelperProvider.CapitalizeFirstLetterOfEachWord(State);
var lenTest = new Regex(@".{1,40}");
if (!lenTest.IsMatch(State))
{
errors.Add(19);
}
var rx = new Regex(@"^[A-Za-z'.\- ]*$");
if (!rx.IsMatch(State))
{
errors.Add(20);
}
return(errors);
}
}
}
public async Task <JsonResult> GetApiToken(string task)
{
_logger.LogInformation("WaterController.GetApiToken - Service starts.");
var tokenLength = HelperProvider.RandomNumberInRange(30, 100);
var token = new TokenVM {
Token = HelperProvider.GenerateRandomString(tokenLength),
Duration = TOKEN_LIFE,
Target = HidroConstants.API_TOKEN_TARGETS[task]
};
var result = await _tokenService.SetApiToken(token);
if (!result)
{
return(new JsonResult(new { Result = RESULTS.FAILED, Message = "An error occurred while attempting to load your photos. Please reload page to try again." }));
}
return(new JsonResult(new { Result = RESULTS.SUCCESS, Message = token.Token }));
}
public async Task <PaymentDetailVM> InsertNewPaymentMethod(PaymentDetailVM paymentDetail)
{
_logger.LogInformation("PaymentService.InsertNewPaymentMethod - Service starts.");
var dbPaymentMethod = new PaymentMethod();
if (paymentDetail.PaymentMethod.CreditCard != null)
{
dbPaymentMethod = new PaymentMethod {
HolderName = paymentDetail.PaymentMethod.CreditCard.HolderName,
CardNumber = paymentDetail.PaymentMethod.CreditCard.CardNumber,
ExpiryDate = HelperProvider.ParseDateTimeString(paymentDetail.PaymentMethod.CreditCard.ExpiryDate, DATE_FORMATS.MONTH_YEAR.GetValue()),
SecurityCode = paymentDetail.PaymentMethod.CreditCard.SecurityCode,
CardAddedOn = DateTime.UtcNow
}
}
;
if (paymentDetail.PaymentMethod.Paypal != null)
{
dbPaymentMethod = new PaymentMethod {
PaypalAddress = paymentDetail.PaymentMethod.Paypal.Email,
PaypalAddedOn = DateTime.UtcNow
}
}
;
dbPaymentMethod.HidrogenianId = paymentDetail.HidrogenianId;
_dbContext.PaymentMethod.Add(dbPaymentMethod);
try {
await _dbContext.SaveChangesAsync();
} catch (Exception e) {
_logger.LogError("PaymentService.InsertNewPaymentMethod - Error: " + e);
return(null);
}
paymentDetail.PaymentMethod.Id = dbPaymentMethod.Id;
return(paymentDetail);
}
public async Task <KeyValuePair <string, string> > SetTempPasswordAndRecoveryToken(RecoveryVM recoveree)
{
_logger.LogInformation("AuthenticationService.SetTempPasswordAndRecoveryToken - Service starts.");
var dbHidrogenian = !recoveree.Reattempt ? await _dbContext.Hidrogenian.FirstOrDefaultAsync(
h => h.Email == recoveree.Email && h.EmailConfirmed && h.DeactivatedOn == null)
: await _dbContext.Hidrogenian.FirstOrDefaultAsync(
h => h.Email == recoveree.Email && !h.EmailConfirmed && h.DeactivatedOn == null &&
h.RecoveryToken != null && h.TokenSetOn != null);
if (dbHidrogenian == null)
{
return(new KeyValuePair <string, string>(null, null));
}
var tempPassword = HelperProvider.GenerateRandomString(15);
var hashedResult = GenerateHashedPasswordAndSalt(tempPassword);
dbHidrogenian.PasswordHash = hashedResult.Key;
dbHidrogenian.PasswordSalt = hashedResult.Value;
var recoveryToken = GenerateRandomToken();
dbHidrogenian.RecoveryToken = recoveryToken;
dbHidrogenian.TokenSetOn = DateTime.UtcNow;
dbHidrogenian.EmailConfirmed = false;
_dbContext.Hidrogenian.Update(dbHidrogenian);
try {
await _dbContext.SaveChangesAsync();
} catch (Exception e) {
_logger.LogError("AuthenticationService.SetTempPasswordAndRecoveryToken - Error: " + e);
return(new KeyValuePair <string, string>(string.Empty, null));
}
return(new KeyValuePair <string, string>(tempPassword, recoveryToken));
}
public ActionResult <string> PublishVersion(int version, int isMust)
{
HttpResultModel ret = new HttpResultModel();
ret.result = Result.SUCCESS;
try
{
Redis redis = HelperProvider.GetRedis();
string result = Convert.ToString(redis.StringSet("appVersion", version));
result += Convert.ToString(redis.StringSet("updateIsMust", isMust));
ret.data = result;
}
catch (Exception ex)
{
ret.result = Result.ERROR;
ret.errorCode = MainErrorModels.LOGIC_ERROR;
ret.message = Convert.ToString(MainErrorModels.LOGIC_ERROR);
Log.WriteErrorLog("MainController::GetCertificate", "异常：{0}", ex.Message);
}
return(JsonConvert.SerializeObject(ret));
}
public SqlServerChangeTrackingTcpTests(HelperProvider fixture, ITestOutputHelper output) : base(fixture, output)
{
}
public MySqlHttpTests(HelperProvider fixture, ITestOutputHelper output) : base(fixture, output)
{
}
public MySqlTcpFilterTests(HelperProvider fixture, ITestOutputHelper output) : base(fixture, output)
{
}
