public IHttpActionResult Post(EmailAccountEntityModel entityModel) { if (!ModelState.IsValid) { return(BadRequest()); } //create a new email account var emailAccount = new EmailAccount() { Id = entityModel.Id, Email = entityModel.Email, UserName = entityModel.UserName, FromName = entityModel.FromName, Host = entityModel.Host, UseSsl = entityModel.UseSsl, Port = entityModel.Port, UseDefaultCredentials = entityModel.UseDefaultCredentials, Password = _cryptographyService.Encrypt(entityModel.Password) }; //if this is the first account, we'll set it as default emailAccount.IsDefault = _emailAccountService.Count() == 0; //save it _emailAccountService.Insert(emailAccount); VerboseReporter.ReportSuccess("Successfully saved email account", "post_emailaccount"); return(RespondSuccess(new { EmailAccount = emailAccount.ToEntityModel() })); }
public IActionResult Post([FromBody] CredentialViewModel param) { User requestor = _context.Users.SingleOrDefault(u => u.ApiKey == Request.Headers["X-ApiKey"]); if (requestor.IsAdmin) { if (ModelState.IsValid) { Credential cred = new Credential { UserName = param.UserName, Password = _cryptoService.Encrypt(param.Password) }; _context.Credentials.Add(cred); _context.SaveChanges(); return(Ok(cred)); } else { return(BadRequest(ModelState)); } } else { throw new Exception("Only administrator users can add new credentials."); } }
public async Task <bool> VerifyUserPasswordAsync(long userId, string password, string salt) { LinUserIdentity userIdentity = await this.GetFirstByUserIdAsync(userId); string encryptPassword = _cryptographyService.Encrypt(password, salt); return(userIdentity != null && userIdentity.Credential == encryptPassword); }
public async Task <IResult> Handler(CadastrarUsuarioCommand command) { command.Validate(); if (!command.Valid) { return(command.ValidationResult); } var usuario = await _repository.Usuario.GetUsuarioByNomeAsync(command.Nome); if (usuario != null) { return(new CommandResult(false, "Já existe um usuário com mesmo nome cadastrado", command.Notifications)); } usuario = await _repository.Usuario.GetUsuarioByLoginAsync(command.Login); if (usuario != null) { return(new CommandResult(false, "Login já cadastrado", command.Notifications)); } usuario = await _repository.Usuario.GetUsuarioBySiglaAsync(command.Sigla); if (usuario != null) { return(new CommandResult(false, "Já existe um usuário com a mesma sigla cadastrada", command.Notifications)); } var setor = await _repository.Setor.GetSetorByIdAsync(command.SetorId); if (setor == null) { return(new CommandResult(false, "Setor não encontrado", command.Notifications)); } var usuarioEntity = _mapper.Map <Usuario>(command); var passwordEncrypted = _cryptographyService.Encrypt(usuarioEntity.Senha); usuarioEntity.Setor = setor; usuarioEntity.Senha = passwordEncrypted; _repository.Usuario.Create(usuarioEntity); await _repository.SaveAsync(); return(new CommandResult("Usuário cadastrado com sucesso!")); }
/// <summary> /// Adds a new PatientRecordEntry /// </summary> /// <param name="newPatientRecordEntry"></param> /// <returns></returns> public async Task <PatientNoteDto> AddPatientRecordEntryAsync(PatientNoteDto newPatientRecordEntry) { if (newPatientRecordEntry == null) { throw new ArgumentNullException(nameof(newPatientRecordEntry)); } var newPatientRecordEntryString = JsonSerializer.Serialize(newPatientRecordEntry); var encryptedContent = _cryptoSvc.Encrypt(newPatientRecordEntryString); var newPatientNote = new PatientNote() { PatientId = newPatientRecordEntry.PatientId, MedicalPractitionerId = newPatientRecordEntry.MedicalPractitionerId, Timestamp = newPatientRecordEntry.Timestamp, Content = encryptedContent }; var result = await _noteDal.AddAsync(newPatientNote); if (result == null) { return(null); } newPatientRecordEntry.Id = result.Id; return(newPatientRecordEntry); }
public void CryptographyServiceEncrypt() { string guid = Guid.NewGuid().ToString(); string encrptypassword = _cryptographyService.Encrypt("123qwe", guid); _testOutputHelper.WriteLine($"guid:{guid},passowrd:{encrptypassword}"); }
public async Task InvokeAsync(HttpContext context) { if (string.IsNullOrWhiteSpace(context.Request.ContentType)) { //context.Response.StatusCode = (int) HttpStatusCode.BadRequest; //context.GetEndpoint(); context.Request.ContentType = "text/plain"; await _next(context); return; } var secureHeader = _configuration.GetValue <string>("AppSetting:SecureHeader"); // default is ft-ejson if (context.Request.ContentType != secureHeader) { await _next(context); return; } var encryptionKey = _configuration.GetValue <string>("AppSetting:ApiEncryptionKey"); if (context.Response.ContentLength.GetValueOrDefault(0) == 0) // Input Request { using (var reader = new StreamReader(context.Request.Body, Encoding.UTF8)) { var cipherBody = reader.ReadToEnd(); var body = _securityService.Decrypt(cipherBody, encryptionKey); context.Request.Body.Flush(); context.Request.Body.Write(Encoding.UTF8.GetBytes(body), 0, body.Length); } await _next(context); return; } else // Output Response { using (var reader = new StreamReader(context.Response.Body, Encoding.UTF8)) { var body = reader.ReadToEnd(); var cipherBody = _securityService.Encrypt(body, encryptionKey); context.Response.Body.Flush(); context.Response.Body.Write(Encoding.UTF8.GetBytes(cipherBody), 0, cipherBody.Length); context.Response.ContentType = "ft-ejson"; } await _next(context); return; } }
public void Set(HttpContext context, AuthenticationSessionViewModel sessionViewModel) { var cipherSession = _cryptographyService.Encrypt(sessionViewModel, _encryptionKey); var session = Encoding.UTF8.GetBytes(cipherSession); context.Session.Set(_sessionName, session); }
public async Task <Usuario> GetUsuarioAsync(string login, string password) { var passwordEncrypted = _cryptographyService.Encrypt(password); var usuario = await _repository.Usuario.GetUsuarioAsync(login, passwordEncrypted); return(usuario); }
public async Task SaveAsync <T>(string filename, T model) { var json = JsonConvert.SerializeObject(model); var encryptedJson = _cryptographyService.Encrypt(json); await _ioService.SaveAsync(filename, encryptedJson); }
public void Encrypt_Decrypt() { const string value = nameof(SecurityTests); var crypt = _cryptographyService.Encrypt(value); var decrypt = _cryptographyService.Decrypt(crypt); Assert.AreEqual(value, decrypt); }
public void SetUserConsents(int userId, Dictionary <int, ConsentStatus> consentPairs) { var allConsents = _consentService.Get(x => x.Published).ToList(); var savedConsents = GetUserConsents(userId); var user = _userService.Get(userId); IList <ConsentLog> logs = new List <ConsentLog>(); foreach (var(consentId, consentStatus) in consentPairs) { var consent = allConsents.FirstOrDefault(x => x.Id == consentId); if (consent == null || (consent.IsRequired && consentStatus != ConsentStatus.Accepted)) { continue; } var savedConsent = savedConsents.FirstOrDefault(x => x.ConsentId == consentId); var log = false; if (savedConsent == null) { savedConsent = new UserConsent() { ConsentId = consentId, UserId = userId, ConsentStatus = consentStatus }; EntitySet <UserConsent> .Insert(savedConsent); log = true; } else if (savedConsent.ConsentStatus != consentStatus) { savedConsent.ConsentStatus = consentStatus; EntitySet <UserConsent> .Update(savedConsent); log = true; } if (consent.EnableLogging && log) { //add to log logs.Add(new ConsentLog() { ActivityType = consentStatus == ConsentStatus.Accepted ? ActivityType.ConsentAccepted : ActivityType.ConsentDenied, ConsentId = consentId, UserId = userId, CreatedOn = DateTime.UtcNow, EncryptedUserInfo = _cryptographyService.Encrypt(user.Email) }); } } //commit the logs to db _consentLogService.Insert(logs.ToArray()); }
public void CryptographyService() { const string value = nameof(SecurityTests); var salt = Guid.NewGuid().ToString(); var crypt = _cryptographyService.Encrypt(value, salt); var decrypt = _cryptographyService.Decrypt(crypt, salt); Assert.AreEqual(value, decrypt); }
internal HeroViewModel(Hero hero, ICryptographyService cryptographyService) { Id = cryptographyService.Encrypt(hero.Id); Name = hero.Name; FreeToPlayPeriods = hero .FreeToPlayPeriods .Select(ftpp => new FreeToPlayPeriodViewModel(ftpp, cryptographyService)) .ToArray(); Type = new HeroTypeViewModel(hero.Type, cryptographyService); State = new HeroStateViewModel(hero.State, cryptographyService); Created = hero.Created; Price = hero.Price; }
/// <summary> /// Gets the user. /// </summary> /// <returns></returns> public Domain.Model.User GetUser() { Domain.Model.User user = new Domain.Model.User { DisplayName = DisplayName, Email = Email, FirstName = FirstName, LastName = LastName, Password = _cryptographyService.Encrypt(Password), Username = Username }; return(user); }
public IActionResult SaveEmailAccount(EmailAccountModel model) { var emailAccount = model.Id > 0 ? _emailAccountService.Get(model.Id) : new EmailAccount(); if (emailAccount == null) { return(NotFound()); } _modelMapper.Map(model, emailAccount, nameof(EmailAccount.Id), nameof(EmailAccount.Password)); if (!model.Password.IsNullEmptyOrWhiteSpace()) { emailAccount.Password = _cryptographyService.Encrypt(model.Password); } _emailAccountService.InsertOrUpdate(emailAccount); if (model.IsDefault) { //mark all the others as non default _emailSenderSettings.DefaultEmailAccountId = emailAccount.Id; _settingService.Save(_emailSenderSettings, CurrentStore.Id); } return(R.Success.Result); }
public async Task <Unit> Handle(AddResourceCommand request, CancellationToken cancellationToken) { var collection = await _repository.GetbyId(request.CollectionId); if (collection != null) { var source = await _service.Encrypt(request.Id, request.Resource); collection.AddResource(request.Id, request.OwnerId, request.OwnerName, source, request.Name); await _repository.UpdateAsync(collection); } return(Unit.Value); }
/// <summary> /// Handles the PreSendRequestHeaders event of the context control. /// </summary> /// <param name="sender">The source of the event.</param> /// <param name="e">The <see cref="System.EventArgs"/> instance containing the event data.</param> public void ContextPreSendRequestHeaders(object sender, EventArgs e) { HttpCookie cookie = _context.Context.Items[SiteCookie.CookieName] as HttpCookie; if (cookie != null && !string.IsNullOrEmpty(cookie.Value)) { HttpCookie calEmaCookie = new HttpCookie(SiteCookie.CookieName) { Value = _cryptographyService.Encrypt(cookie.Value) }; _context.Response.Cookies.Remove(SiteCookie.CookieName); _context.Response.Cookies.Add(calEmaCookie); } }
public bool Login(UserAuthenticate model) { if (model == null) { throw new Exception("User cannot be empty."); } if (string.IsNullOrEmpty(model.Username) || string.IsNullOrEmpty(model.Password)) { throw new Exception("Username or password cannot be empty."); } model.Password = _cryptographyService.Encrypt(model.Password); return(_accountRepository.VerifyUser(model)); }
/// <summary> /// Sets the value. /// </summary> /// <param name="key">The key.</param> /// <param name="val">The val.</param> public void Set(string key, string val) { HttpCookie cookie = _contextBase.Items[_cookieName] as HttpCookie ?? (_contextBase.Request.Cookies[_cookieName] ?? new HttpCookie(_cookieName)); if (!string.IsNullOrEmpty(cookie.Value)) { cookie = new HttpCookie(_cookieName, _cryptographyService.Decrypt(cookie.Value)); } cookie.Values.Remove(key); cookie.Values[key] = val; _contextBase.Response.Cookies[_cookieName].Value = _cryptographyService.Encrypt(cookie.Value); _contextBase.Items[_cookieName] = _contextBase.Response.Cookies[_cookieName]; }
public void Set(HttpContext context, AuthenticationCookieViewModel cookieViewModel, CookieOptions options) { var cipherAuthenticationCookie = _cryptographyService.Encrypt(cookieViewModel, _encryptionKey); if (!options.Expires.HasValue) { var timeSpan = cookieViewModel.RememberMe ? TimeSpan.FromDays(30) : TimeSpan.FromHours(1); options.Expires = DateTimeOffset.Now.Add(timeSpan); } if (!options.MaxAge.HasValue) { var maxAge = cookieViewModel.RememberMe ? TimeSpan.FromDays(180) : TimeSpan.FromDays(1); options.MaxAge = maxAge; } context.Response.Cookies.Append(cipherAuthenticationCookie, _cookieName, options); }
private async Task <DocumentFile> BuildFromFileAsync(IFormFile file) { // detect image dimensions string dimensions = null; try { using (Stream fileStream = file.OpenReadStream()) using (Image image = Image.FromStream(fileStream, false, true)) dimensions = $"{image.Width},{image.Height}"; } catch { } // copy file FileInfo fileInfo = new FileInfo(_settings.BuildFilePath(GenerateUniqueFileName())); // copy in resources folder using (var stream = new FileStream(fileInfo.FullName, FileMode.Create)) await file.CopyToAsync(stream); // encrypt file string iv = Guid.NewGuid().ToString().AsSpan(0, 16).ToString(); byte[] cipher = _cryptographyService.Encrypt(await File.ReadAllBytesAsync(fileInfo.FullName), Encoding.UTF8.GetBytes(_settings.EncryptKey), Encoding.UTF8.GetBytes(iv)); await File.WriteAllBytesAsync(fileInfo.FullName, cipher); // create document file DocumentFile result = new DocumentFile { OriginalName = file.FileName, Path = fileInfo.Name, Encryption = _cryptographyService.Name, IV = iv, Size = fileInfo.Length, Dimensions = dimensions, MimeType = file.ContentType, }; return(result); }
public async Task CreateAsync(LinUser user, List <long> groupIds, string password) { if (!string.IsNullOrEmpty(user.Username)) { bool isRepeatName = await _userRepository.Select.AnyAsync(r => r.Username == user.Username); if (isRepeatName) { throw new LinCmsException("用户名重复,请重新输入", ErrorCode.RepeatField); } } if (!string.IsNullOrEmpty(user.Email.Trim())) { var isRepeatEmail = await _userRepository.Select.AnyAsync(r => r.Email == user.Email.Trim()); if (isRepeatEmail) { throw new LinCmsException("注册邮箱重复,请重新输入", ErrorCode.RepeatField); } } user.Salt = Guid.NewGuid().ToString(); string encryptPassword = _cryptographyService.Encrypt(password, user.Salt); user.LinUserGroups = new List <LinUserGroup>(); groupIds?.ForEach(groupId => { user.LinUserGroups.Add(new LinUserGroup() { GroupId = groupId }); }); user.LinUserIdentitys = new List <LinUserIdentity>() { new LinUserIdentity(LinUserIdentity.Password, user.Username, encryptPassword, DateTime.Now) }; await _userRepository.InsertAsync(user); }
private async static Task RunAsync() { Console.WriteLine($"Plain Text: {PlainText}"); OneWayEncrpytionService = new MD5CryptographyService(); var hash = OneWayEncrpytionService.Encrypt(PlainText); Console.WriteLine($"MD5 Hashed: {hash}"); OneWayEncrpytionService = new HashCryptographyService(new SHA1Managed()); hash = OneWayEncrpytionService.Encrypt(PlainText); Console.WriteLine($"SHA1 Hashed: {hash}"); var symmetricAlgorithmCryptographyService = new SymmetricAlgorithmCryptographyService( new AesCryptoServiceProvider { Mode = CipherMode.CBC, KeySize = 128, Key = Encoding.UTF8.GetBytes("1234567890123456"), IV = Encoding.UTF8.GetBytes("0234567890123456") }); CryptographyService = symmetricAlgorithmCryptographyService; var encryptedText = CryptographyService.Encrypt(PlainText); Console.WriteLine($"AES Encrypted: {encryptedText}"); var decryptedText = CryptographyService.Decrypt(encryptedText).Trim(); Console.WriteLine($"AES Decrypted: {decryptedText}"); const string filename = "Credentials.txt"; var encryptedPersister = new EncryptedPersister(CryptographyService, new FileIOService()); await encryptedPersister.SaveAsync(filename, new Credentials { Username = "******", Password = "******" }); var credentials = await encryptedPersister.LoadAsync<Credentials>(filename); Console.WriteLine($"AES Encrypted File: {await File.ReadAllTextAsync(filename)}"); Console.WriteLine($"AES Decrypted Credentials Username: {credentials.Username} Password: {credentials.Password}"); }
public ActionResult Index(string username, AccountDetailsView detailsView) { IDictionary <string, string> crumbs = GetBreadCrumbs("details", UrlService.UserUrl("account")); if (ModelState.IsValid) { detailsView.Password = _cryptographyService.Encrypt(detailsView.Password); Domain.Model.User savedUser = detailsView.GetUser(); savedUser.Settings = Owner.Settings; savedUser.Id = Owner.Id; _userRepository.Save(savedUser); detailsView.UIMessage = "Account details saved."; detailsView.Password = _cryptographyService.Decrypt(savedUser.Password); detailsView = SetAuthorizationAndUrlService(detailsView); detailsView.Authorization.Owner = savedUser; } else { ValidationHelper.ValidationHackRemoveNameAndBlankKey(ModelState); } return(View(detailsView, crumbs)); }
internal HeroTypeViewModel(HeroType heroType, ICryptographyService cryptographyService) { Id = cryptographyService.Encrypt(heroType.Id); Name = heroType.Name; }
internal FreeToPlayPeriodViewModel(FreeToPlayPeriod freeToPlayPeriod, ICryptographyService cryptographyService) { Id = cryptographyService.Encrypt(freeToPlayPeriod.Id); Begin = freeToPlayPeriod.Begin; End = freeToPlayPeriod.End; }
public IActionResult PaymentInfoSave(PaymentMethodModel requestModel) { Order order = null; Cart cart = null; if (!requestModel.OrderGuid.IsNullEmptyOrWhiteSpace()) { order = _orderService.GetByGuid(requestModel.OrderGuid); if (order == null || order.PaymentStatus != PaymentStatus.Pending) { return(R.Fail.With("error", T("The order has been already paid")).Result); } } else { if (!CanCheckout(out cart)) { return(R.Fail.Result); } } if (order == null && cart == null) { return(R.Fail.Result); } var paymentMethodRequired = true; //can we use store credits if (_affiliateSettings.AllowStoreCreditsForPurchases && requestModel.UseStoreCredits) { //get the balance var balance = _storeCreditService.GetBalance(CurrentUser.Id); paymentMethodRequired = _affiliateSettings.MinimumStoreCreditsToAllowPurchases > balance || balance < (order?.OrderTotal ?? cart.FinalAmount); } IPaymentHandlerPlugin paymentHandler = null; var formAsDictionary = requestModel.FormCollection.Keys.ToDictionary(x => x, x => requestModel.FormCollection[x].ToString()); if (paymentMethodRequired) { //check if payment method is valid paymentHandler = PluginHelper.GetPaymentHandler(requestModel.SystemName); if (paymentHandler == null) { return(R.Fail.With("error", T("Payment method unavailable")).Result); } if (!paymentHandler.ValidatePaymentInfo(formAsDictionary, out string error)) { return(R.Fail.With("error", error).Result); } } CustomResponse response; if (order != null) { order.PaymentMethodName = requestModel.SystemName; order.PaymentMethodFee = paymentMethodRequired ? paymentHandler.GetPaymentHandlerFee(order) : 0; order.OrderTotal = order.Subtotal + order.Tax + (order.PaymentMethodFee ?? 0) + (order.ShippingMethodFee ?? 0); //check if discount is available if (order.DiscountId.HasValue) { if (_priceAccountant.CanApplyDiscount(order.DiscountId.Value, order.UserId, out _)) { order.OrderTotal -= order.Discount; } } _orderService.Update(order); var creditAmount = 0m; if (requestModel.UseStoreCredits) { //do we have available credit GetAvailableStoreCredits(out _, out creditAmount, ApplicationEngine.BaseCurrency, null); } //process the payment immediately ProcessPayment(order, creditAmount, formAsDictionary.ToDictionary(x => x.Key, x => (object)x.Value), out response); return(response.Result); } else { //if we are here, the payment method can be saved cart.PaymentMethodName = paymentMethodRequired ? requestModel.SystemName : ""; //always store encrypted information about payment data cart.PaymentMethodData = _cryptographyService.Encrypt(_dataSerializer.Serialize(formAsDictionary)); cart.PaymentMethodDisplayName = paymentMethodRequired ? paymentHandler.PluginInfo.Name : "Store Credits"; cart.UseStoreCredits = requestModel.UseStoreCredits; _cartService.Update(cart); RaiseEvent(NamedEvent.OrderPaymentInfoSaved, cart); } response = R.Success; if (!requestModel.OrderGuid.IsNullEmptyOrWhiteSpace()) { response.With("orderGuid", requestModel.OrderGuid); } return(response.Result); }
public string Encrypt(T content, string salt) { var serializedContent = JsonConvert.SerializeObject(content); return(cryptoService.Encrypt(serializedContent, salt)); }
public IHttpActionResult ProcessPayment(FormCollection parameters) { //first get the payment processor var paymentMethodName = parameters.Get(PaymentParameterNames.PaymentMethodTypeName); if (string.IsNullOrEmpty(paymentMethodName)) { VerboseReporter.ReportError("Invalid payment method", "process_payment"); return(RespondFailure()); } //the transaction amount decimal amount; var amountString = parameters.Get(PaymentParameterNames.Amount) ?? "0"; decimal.TryParse(amountString, out amount); PaymentMethodType methodType; if (System.Enum.TryParse(paymentMethodName, out methodType)) { methodType = PaymentMethodType.CreditCard; } //get the payment processor now var paymentProcessor = _paymentProcessingService.GetPaymentProcessorPlugin(amount, methodType); if (paymentProcessor == null) { VerboseReporter.ReportError("Invalid payment method", "process_payment"); return(RespondFailure()); } //convert form collection to dictionary to check if parameters are valid var formCollectionDictionary = parameters.ToDictionary(pair => pair.Key, pair => (object)pair.Value); var isValid = paymentProcessor.AreParametersValid(formCollectionDictionary); UserPaymentMethod paymentMethod = null; if (!isValid) { //the parameters are not valid. but that may also mean that the user is selecting an already saved payment method //and so he wouldn't have sent that data again var savedPaymentMethodIdString = parameters.Get(PaymentParameterNames.UserSavedPaymentMethodId); int savedPaymentMethodId; if (int.TryParse(savedPaymentMethodIdString, out savedPaymentMethodId)) { var userPaymentMethods = _paymentMethodService.Get(x => x.UserId == ApplicationContext.Current.CurrentUser.Id && x.Id == savedPaymentMethodId, null); if (userPaymentMethods.Any()) { paymentMethod = userPaymentMethods.First(); isValid = true; } } //still invalid? something is not right then. if (!isValid) { VerboseReporter.ReportError("Invalid parameters to process payment", "process_payment"); return(RespondFailure()); } } //we save the payment method in our database if it's CreditCard if (paymentProcessor.Supports(PaymentMethodType.CreditCard)) { if (paymentMethod == null) { #region saving payment method to database var creditCardNumber = parameters.Get(PaymentParameterNames.CardNumber); //let's validate the card for level 1 check (luhn's test) first before storing var isCardValid = PaymentCardHelper.IsCardNumberValid(creditCardNumber); //card number if (!isCardValid) { VerboseReporter.ReportError("Invalid card number", "process_payment"); return(RespondFailure()); } //expiration date var expireMonth = parameters.Get(PaymentParameterNames.ExpireMonth); var expireYear = parameters.Get(PaymentParameterNames.ExpireYear); if (!expireYear.IsInteger() || !expireMonth.IsInteger()) { VerboseReporter.ReportError("Invalid expiration month or year", "process_payment"); return(RespondFailure()); } //card issuer var cardIssuer = PaymentCardHelper.GetCardTypeFromNumber(creditCardNumber); if (!cardIssuer.HasValue) { VerboseReporter.ReportError("Unsupported card provider", "process_payment"); return(RespondFailure()); } var nameOnCard = parameters.Get(PaymentParameterNames.NameOnCard); //encrypt credit card info to store in db var key = ConfigurationManager.AppSettings.Get("EncryptionKey"); var salt = ConfigurationManager.AppSettings.Get("Salt"); var cardNumber = _cryptographyService.Encrypt(creditCardNumber, key, salt); //encrypt the card info //fine if the card is valid, but is the card number already in our record, then not possible to save the same again if (_paymentMethodService.DoesCardNumberExist(cardNumber)) { VerboseReporter.ReportError("The card number is already saved in records", "process_payment"); return(RespondFailure()); } paymentMethod = new UserPaymentMethod() { UserId = ApplicationContext.Current.CurrentUser.Id, IsVerified = false, PaymentMethodType = PaymentMethodType.CreditCard, CardIssuerType = cardIssuer.ToString().ToLowerInvariant(), CardNumber = creditCardNumber, CardNumberMasked = PaymentCardHelper.MaskCardNumber(creditCardNumber), NameOnCard = nameOnCard, }; //save this payment method _paymentMethodService.Insert(paymentMethod); #endregion } } //we need to see if we should only authorize or capture as well //the idea is if it's a sponsorship context, it's better to authorize the payment transaction and capture later when //the sponsorship is accepted //we thought of initially only authorizing sponsorship transactions and capture when it's accepted. //but that flow doesn't seem to work quite well, thoughts? var authorizeOnly = false; // (parameters.Get(PaymentParameterNames.PaymentContext) ?? string.Empty) == "sponsor"; //so we are ready for payment processing, let's create a paymenttrasaction for storing in our db var paymentTransaction = new PaymentTransaction() { IsLocalTransaction = true, PaymentStatus = PaymentStatus.Pending, TransactionAmount = amount, TransactionGuid = Guid.NewGuid(), CreatedOn = DateTime.UtcNow, UserIpAddress = WebHelper.GetClientIpAddress() }; _paymentTransactionService.Insert(paymentTransaction); //now proceed further with the payment //create the transaction request var transactionRequest = new TransactionRequest() { Amount = amount, CurrencyIsoCode = "USD",//TODO: SET CURRENCY AS SELECTED BY USER PaymentProcessorSystemName = paymentProcessor.PluginInfo.SystemName, UserId = ApplicationContext.Current.CurrentUser.Id, Parameters = formCollectionDictionary, TransactionUniqueId = paymentTransaction.TransactionGuid.ToString() }; var response = paymentProcessor.Process(transactionRequest, authorizeOnly); //update values of transaction parameters for future reference paymentTransaction.TransactionCodes = response.ResponseParameters; //update payment transaction _paymentTransactionService.Update(paymentTransaction); if (response.Success) { //let's verify the payment method first if it's not if (paymentMethod != null && !paymentMethod.IsVerified) { paymentMethod.IsVerified = true; _paymentMethodService.Update(paymentMethod); } //now since the response was success, we can actually assign some credits to the user var creditCount = amount * (1 / _paymentSettings.CreditExchangeRate); var credit = new Credit() { PaymentTransactionId = paymentTransaction.Id, CreatedOnUtc = DateTime.UtcNow, CreditCount = creditCount, CreditExchangeRate = _paymentSettings.CreditExchangeRate, //if it's authorize only transaction, we assign the credits, but they won't be usable before they are approved by capture CreditTransactionType = CreditTransactionType.Issued, CreditType = CreditType.Transactional, IsExpired = false }; //save credit _creditService.Insert(credit); //get total available credits of user var usableCreditCount = _creditService.GetUsableCreditsCount(ApplicationContext.Current.CurrentUser.Id); return(RespondSuccess(new { UsableCreditCount = usableCreditCount })); } VerboseReporter.ReportError("An error occured while processing payment", "process_payment"); return(RespondFailure()); }
public string Encrypt(string text) { return(_cryptographyService.Encrypt(text, configuration["Authentication:SecretKey"])); }