public bool validateRecaptcha(string response) { bool valid = false; //Request to Google Server HttpWebRequest req = (HttpWebRequest)WebRequest.Create($"https://www.google.com/recaptcha/api/siteverify?secret={_secretKey}&response={response}"); try { //Google recaptcha Responce using (WebResponse wResponse = req.GetResponse()) { using (StreamReader readStream = new StreamReader(wResponse.GetResponseStream())) { string jsonResponse = readStream.ReadToEnd(); JavaScriptSerializer js = new JavaScriptSerializer(); RecaptchaResponse data = js.Deserialize <RecaptchaResponse>(jsonResponse);// Deserialize Json valid = Convert.ToBoolean(data.success); } } return(valid); } catch (WebException ex) { throw ex; } }
/// <summary> /// The validate. /// </summary> public void Validate() { if (this.skipRecaptcha) { this.recaptchaResponse = RecaptchaResponse.Valid; } else { var validator = new RecaptchaValidator { PrivateKey = this.privateKey, RemoteIP = Utils.GetClientIP() }; if (String.IsNullOrEmpty(this.RecaptchaChallengeValue) && String.IsNullOrEmpty(this.RecaptchaResponseValue)) { validator.Challenge = this.Context.Request.Form[RecaptchaChallengeField]; validator.Response = this.Context.Request.Form[RecaptchaResponseField]; } else { validator.Challenge = this.RecaptchaChallengeValue; validator.Response = this.RecaptchaResponseValue; } this.recaptchaResponse = validator.Validate(); } }
private void CheckReCaptcha(RecaptchaResponse recaptchaResponse, StringBuilder reasonForModeration) { if (!recaptchaResponse.success) { reasonForModeration.AppendLine("reCAPTCHA success is false"); } if (recaptchaResponse.score < _settings.ReCaptchaMinimumScore) { reasonForModeration.AppendLine( $"reCAPTCHA score < minimum required score ({recaptchaResponse.score} < {_settings.ReCaptchaMinimumScore})"); } if (string.Compare(recaptchaResponse.hostname, _settings.ReCaptchaHostname, StringComparison.InvariantCultureIgnoreCase) != 0) { reasonForModeration.AppendLine( $"reCAPTCHA hostname != expected hostname ('{recaptchaResponse.hostname}' != '{_settings.ReCaptchaHostname}')"); } if (string.Compare(recaptchaResponse.action, _settings.ReCaptchaAction, StringComparison.InvariantCultureIgnoreCase) != 0) { reasonForModeration.AppendLine( $"reCAPTCHA action != expected action ('{recaptchaResponse.action}' != '{_settings.ReCaptchaAction}')"); } }
public void Validate() { if (skipRecaptcha) { recaptchaResponse = RecaptchaResponse.Valid; } else { RecaptchaValidator validator = new RecaptchaValidator(); validator.PrivateKey = privateKey; validator.RemoteIP = Page.Request.UserHostAddress; if (String.IsNullOrEmpty(RecaptchaChallengeValue) && String.IsNullOrEmpty(RecaptchaResponseValue)) { validator.Challenge = Context.Request.Form[RECAPTCHA_CHALLENGE_FIELD]; validator.Response = Context.Request.Form[RECAPTCHA_RESPONSE_FIELD]; } else { validator.Challenge = RecaptchaChallengeValue; validator.Response = RecaptchaResponseValue; } recaptchaResponse = validator.Validate(); } }
private void TasksProccesing() { if (ReferenceEquals(_tasks, null) || _tasks.Count.Equals(0)) { return; } try { foreach (var item in _tasks.Where(el => el.Status.Equals(RuCaptchaTaskStatus.NotReady))) { var rr = (HttpWebRequest)WebRequest.Create( $"http://rucaptcha.com/res.php?key={CaptchaApiToken}&action=get&id={item.RequestId}&json=1"); using (var r = (HttpWebResponse)rr.GetResponse()) { using (var s = r.GetResponseStream()) { using (var sr = new StreamReader(s)) { RecaptchaResponse = sr.ReadToEnd(); } if (RecaptchaResponse.Equals(CaptchaIsNotReady)) { _logger.Info("Response from Recaptcha not ready... sleepping...."); InvokeOnRecaptchaV2TaskCallback(item); } else if (RecaptchaResponse.Equals(CaptchaIsUnsolvable)) { _logger.Error( "Response from Recaptcha: captcha cannot be solved, check sita settings...."); InvokeOnRecaptchaV2TaskCallback(item); item.Status = RuCaptchaTaskStatus.Unsolvable; } else { var trdto = JsonConvert.DeserializeObject <RucaptchaTaskResponseDto>(RecaptchaResponse); if (!trdto.Data.Equals(CaptchaIsNotReady)) { item.CaptchaSolution = trdto.Data; InvokeOnRecaptchaV2TaskCallback(item); } else { InvokeOnRecaptchaV2TaskCallback(item); _logger.Info("Response from Recaptcha not ready... sleepping...."); } } } } } } catch (Exception exc) { _logger.Error("While trying to check task status in RuCaptcha, exception occured!"); _logger.Exception(exc); } }
/// <summary> /// The validate. /// </summary> public void Validate() { if (this.skipRecaptcha) { this.recaptchaResponse = RecaptchaResponse.Valid; } else { var validator = new RecaptchaValidator { PrivateKey = this.privateKey, RemoteIP = Utils.GetClientIP() }; if (this.RecaptchaResponseValue == null) { validator.Response = this.Context.Request.Form[RecaptchaResponseField]; } else { validator.Response = this.RecaptchaResponseValue; } this.recaptchaResponse = validator.Validate(); } }
public async Task <IActionResult> OnPostUnregisterAsync() { ReferencedCalendarItem = await _repository.GetDocument(CalendarItemId); UseCaptcha = !User.Identity.IsAuthenticated && null != ReferencedCalendarItem && ReferencedCalendarItem.PublicListing; if (UseCaptcha) { RecaptchaResponse captchaValid = await _recaptcha.Validate(Request); if (!captchaValid.success) { ModelState.AddModelError("reCaptcha", "Bitte das reCaptcha bestätigen."); } } if (!ModelState.IsValid) { ViewData["Message"] = "Schiefgegangen"; return(Page()); } Member memberToUnregister; List <Member> members; if (null == ReferencedCalendarItem) { return(new NotFoundResult()); } members = (ReferencedCalendarItem.Members != null) ? new List <Member>(ReferencedCalendarItem.Members) : new List <Member>(); memberToUnregister = members.Find(m => m.EMail == NewMember.EMail && m.Name == NewMember.Name); if (null == memberToUnregister) { ModelState.AddModelError("EMail", "E-Mail und Name stimmen mit keiner Anmeldung überein."); return(Page()); } if (ReferencedCalendarItem.RegistrationKeyRequired) { RegistrationKey checkKey = ReferencedCalendarItem.RegistrationKeys.FirstOrDefault(r => r.Key == NewMember.RegistrationKey); if (null == checkKey) { ModelState.AddModelError("RegistrationKey", "Der angegebene Registrierungsschlüssel ist nicht zulässig."); return(Page()); } } if (ModelState.IsValid) { members.RemoveAll(c => c.UniqueId == memberToUnregister.UniqueId); ReferencedCalendarItem.Members = members.OrderBy(m => m.RegistrationDate).ToArray(); await _repository.UpsertDocument(ReferencedCalendarItem); ViewData["Message"] = "Abgemeldet"; return(RedirectToPage("Index", new { permalink = ReferencedCalendarItem.UrlTitle, message = "Anmeldung gelöscht." })); } else { ViewData["Message"] = "Schiefgegangen"; return(Page()); } }
public override bool Equals(object obj) { RecaptchaResponse other = (RecaptchaResponse)obj; if (other == null) { return(false); } return(other.IsValid == IsValid && other.ErrorCode == ErrorCode); }
public static IRecaptchaService Create(bool success) { var reCaptchaResponse = new RecaptchaResponse { success = success }; var mockReCaptcha = new Mock <IRecaptchaService>(); mockReCaptcha.Setup(m => m.Validate(It.IsAny <HttpRequest>(), It.IsAny <bool>())).ReturnsAsync(reCaptchaResponse); var reCaptcha = mockReCaptcha.Object; return(reCaptcha); }
protected bool IsValidRecaptcha(string recaptchaResponse) { string url = string.Format("https://www.google.com/recaptcha/api/siteverify?secret={0}&response={1}", Config.GOOGLE_CAPTCHA_SECRET, recaptchaResponse); using (HttpClient client = new HttpClient()) { client.DefaultRequestHeaders.Accept.Clear(); client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/x-www-form-urlencoded")); using (HttpResponseMessage response = client.PostAsync(url, null).Result) { RecaptchaResponse result = JsonConvert.DeserializeObject <RecaptchaResponse>(response.Content.ReadAsStringAsync().Result); return(result != null && result.Success); } } }
protected bool IsValidRecaptcha(string recaptchaResponse) { string url = $"https://www.google.com/recaptcha/api/siteverify?secret={Startup.Configuration.GetSection("RecaptchaSecret").Get<string>()}&response={recaptchaResponse}"; using (HttpClient client = new HttpClient()) { client.DefaultRequestHeaders.Accept.Clear(); client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/x-www-form-urlencoded")); using (HttpResponseMessage response = client.PostAsync(url, null).Result) { RecaptchaResponse result = JsonConvert.DeserializeObject <RecaptchaResponse>(response.Content.ReadAsStringAsync().Result); return(result != null && result.Success); } } }
public static bool Validate(HttpContextBase context) { var request = context.Request; var validator = new RecaptchaValidator { PrivateKey = ConfigurationManager.AppSettings["ReCaptchaPrivateKey"], RemoteIP = request.UserHostAddress, Challenge = request.Form[ChallengeFieldKey], Response = request.Form[ResponseFieldKey] }; RecaptchaResponse response = validator.Validate(); return(response.IsValid); }
public async Task <IActionResult> OnPostAsync() { ReferencedCalendarItem = await _repository.GetDocument(CalendarItemId); UseCaptcha = !User.Identity.IsAuthenticated && null != ReferencedCalendarItem && ReferencedCalendarItem.PublicListing; if (UseCaptcha) { RecaptchaResponse captchaValid = await _recaptcha.Validate(Request, false); if (!captchaValid.success) { ModelState.AddModelError("reCaptcha", "Bitte das reCaptcha bestätigen."); } } if (ModelState.IsValid) { if (null == ReferencedCalendarItem) { return(new NotFoundResult()); } if (ReferencedCalendarItem.RegistrationKeyRequired && !User.IsInAnyRole(KnownRoles.CalendarCoordinatorRoles)) { RegistrationKey checkKey = ReferencedCalendarItem.RegistrationKeys.FirstOrDefault(r => r.Key == NewMember.RegistrationKey); if (null == checkKey) { ModelState.AddModelError("RegistrationKey", "Der angegebene Registrierungsschlüssel ist nicht zulässig."); return(Page()); } } List <Member> members = (ReferencedCalendarItem.Members != null) ? new List <Member>(ReferencedCalendarItem.Members) : new List <Member>(); members.RemoveAll(c => c.UniqueId == NewMember.UniqueId); members.Add(NewMember); ReferencedCalendarItem.Members = members.OrderBy(m => m.RegistrationDate).ToArray(); if (ReferencedCalendarItem.GetRegisteredMembersCount() > ReferencedCalendarItem.MaxRegistrationsCount && !User.IsInAnyRole(KnownRoles.CalendarCoordinatorRoles)) { ModelState.AddModelError("RegistrationCount", "Die Anzahl Anmeldungen überschreitet die maximale Teilnehmeranzahl."); return(Page()); } await _repository.UpsertDocument(ReferencedCalendarItem); return(RedirectToPage("Index", new { permalink = ReferencedCalendarItem.UrlTitle, message = "Anmeldung erfolgt." })); } else { return(Page()); } }
private async Task <RecaptchaResponse> GetResponseAsync(String token) { HttpClient client = new HttpClient(); FormUrlEncodedContent requestParams = this.GetParams(token); HttpResponseMessage response = await client.PostAsync(_endpoint, requestParams); String responseString = await response.Content.ReadAsStringAsync(); using (MemoryStream stream = new MemoryStream(Encoding.UTF8.GetBytes(responseString))) { DataContractJsonSerializer serializer = new DataContractJsonSerializer(typeof(RecaptchaResponse)); RecaptchaResponse recaptchaResponse = (RecaptchaResponse)serializer.ReadObject(stream); return(recaptchaResponse); } }
public async Task <DefaultCommandResponse> Handle(CheckClosedCompetitionRegistrationsCommand command) { this._unitOfWork.Begin(); this._registrationUnitOfWork.Begin(); RecaptchaResponse recaptchaResponse = null; try { DateTime end = DateTime.UtcNow; DateTime start = end.AddDays(-2); var closedCompetitions = await this._competitionRepository.GetClosedOnlineCompetitions(start, end); foreach (var competition in closedCompetitions) { var summary = await this._competitionRegistrationSummaryRepository.GetByCompetition(competition.ID); if (summary == null) { List <CompetitionRegistration> registrations = await this._competitionRegistrationRepository.GetAll(competition.ID); await this._registrationEmailManager.SendSummaryEmail(registrations, competition); summary = new CompetitionRegistrationSummary(); summary.CompetitionID = competition.ID; summary.SummarySent = true; summary.SummarySentDate = DateTime.UtcNow; await this._competitionRegistrationSummaryRepository.Save(summary); } } this._unitOfWork.SoftCommit(); this._registrationUnitOfWork.SoftCommit(); //await this._registrationEmailManager.SendConfirmationEmails(registration, this._competition); return(DefaultCommandResponse.Create(new ValidationResult())); } catch (Exception e) { this._unitOfWork.Rollback(); this._registrationUnitOfWork.Rollback(); this._logger.LogError("Error", e); throw; } }
public async Task <IActionResult> OnPostAsync() { RecaptchaResponse captchaValid = await _recaptcha.Validate(Request, false); if (!captchaValid.success) { ModelState.AddModelError("reCaptcha", "Bitte das reCaptcha bestätigen."); } if (ModelState.IsValid) { return(Page()); } else { ViewData["Message"] = "Schiefgegangen"; return(Page()); } }
public async Task <bool> ValidateToken(string token) { HttpRequestMessage message = new HttpRequestMessage(HttpMethod.Post, _recaptchaOptions.Url); var parameters = new Dictionary <string, string>() { { "secret", _recaptchaOptions.SecretKey }, { "response", token } }; message.Content = new FormUrlEncodedContent(parameters); HttpResponseMessage response = await _client.SendAsync(message); RecaptchaResponse responseData = await response.Content.ReadAsAsync <RecaptchaResponse>(); return(responseData.Success); }
public static async Task ProcessCaptchaOrThrowAsync(this HttpRequest request) { if (Engine.Settings.Integrations.EnableGoogleRecaptcha) { var captcha = request.Form["g-recaptcha-response"].FirstOrDefault(); if (captcha.IsSet()) { // process the captcha. using (var client = new HttpClient()) { var remoteIpAddress = request.HttpContext.Connection.RemoteIpAddress.ToString(); var values = new Dictionary <string, string> { { "secret", Engine.Settings.Integrations.GoogleRecaptchaSecretKey }, { "response", captcha }, { "remoteip", remoteIpAddress } }; var content = new FormUrlEncodedContent(values); var responseContent = await client.PostAsync("https://www.google.com/recaptcha/api/siteverify", content); var responseString = await responseContent.Content.ReadAsStringAsync(); RecaptchaResponse response = JsonConvert.DeserializeObject <RecaptchaResponse>(responseString); if (!response.success) { throw new Exception("Sorry, your reCaptcha validation failed."); } if (request.Host.Host != response.hostname) { throw new Exception("Sorry, your reCaptcha validation failed, your host name does not match the validated host name."); } } } else { throw new Exception("Sorry, your reCaptcha validation failed, no captcha response found."); } } }
public async Task <DefaultCommandResponse> Handle(DoublesCompetitionResultEntryCommand command) { var status = false; DefaultCommandResponse response; this._unitOfWork.Begin(); this._registrationUnitOfWork.Begin(); RecaptchaResponse recaptchaResponse = null; try { this._validationResult = await this._validator.ValidateAsync(command); if (this._validationResult.IsValid) { this._unitOfWork.SoftCommit(); this._registrationUnitOfWork.SoftCommit(); //await this._registrationEmailManager.SendConfirmationEmails(registration, this._competition); status = true; response = DefaultCommandResponse.Create(this._validationResult); } else { this._unitOfWork.Rollback(); this._registrationUnitOfWork.Rollback(); response = DefaultCommandResponse.Create(this._validationResult); } } catch (Exception e) { this._unitOfWork.Rollback(); this._registrationUnitOfWork.Rollback(); Console.WriteLine(e); throw; } return(response); }
public ModerationAnalysisReport NeedsModeration(Comment comment, RecaptchaResponse recaptchaResponse, AkismetResponse akismetResponse, KnownCommenterResponse knownCommenterResponse) { var reasonForModeration = new StringBuilder(); CheckReCaptcha(recaptchaResponse, reasonForModeration); CheckAkismet(akismetResponse, reasonForModeration); CheckKnownCommenter(knownCommenterResponse, reasonForModeration); if (reasonForModeration.Length > 0) { _log.LogInformation("Comment needs moderation because: {0}", reasonForModeration.ToString()); } else { _log.LogInformation("Comment does not need moderation"); } return(new ModerationAnalysisReport { NeedsModeration = reasonForModeration.Length > 0, ReasonForModeration = reasonForModeration.ToString() }); }
public override void OnActionExecuting(ActionExecutingContext filterContext) { Roadkill.Core.Mvc.Controllers.ControllerBase controller = filterContext.Controller as Roadkill.Core.Mvc.Controllers.ControllerBase; if (controller != null) { SiteSettings siteSettings = controller.SettingsService.GetSiteSettings(); if (siteSettings.IsRecaptchaEnabled) { string challengeValue = filterContext.HttpContext.Request.Form[CHALLENGE_KEY]; string responseValue = filterContext.HttpContext.Request.Form[RESPONSE_KEY]; RecaptchaValidator validator = new RecaptchaValidator(); validator.PrivateKey = siteSettings.RecaptchaPrivateKey; validator.RemoteIP = filterContext.HttpContext.Request.UserHostAddress; validator.Challenge = challengeValue; validator.Response = responseValue; RecaptchaResponse validationResponse = validator.Validate(); filterContext.ActionParameters["isCaptchaValid"] = validationResponse.IsValid; } } base.OnActionExecuting(filterContext); }
/// <summary> /// Initializes static members of the <see cref="RecaptchaResponse"/> class. /// </summary> static RecaptchaResponse() { Valid = new RecaptchaResponse(true, string.Empty); RecaptchaNotReachable = new RecaptchaResponse(false, "recaptcha-not-reachable"); InvalidSolution = new RecaptchaResponse(false, "incorrect-captcha-sol"); }
public ActionResult Register(string username, string email, string password, string confirmPassword) { // Basic parameter validation if (String.IsNullOrEmpty(username)) { ModelState.AddModelError("username", "You must specify a username.", username); } if (String.IsNullOrEmpty(email)) { ModelState.AddModelError("email", "You must specify an email address.", email); } if (password == null || password.Length < this.Provider.MinRequiredPasswordLength) { string passwordError = String.Format(CultureInfo.CurrentCulture, "You must specify a new password of {0} or more characters.", this.Provider.MinRequiredPasswordLength); ModelState.AddModelError("password", passwordError, password); } if (!String.Equals(password, confirmPassword, StringComparison.Ordinal)) { ModelState.AddModelError("_FORM", "The new password and confirmation password do not match."); } // We don't check the captcha if running localhost and no challenge was given if (this.Request.UserHostAddress == "127.0.0.1" && this.Request.Form["recaptcha_challenge_field"] != null) { // Check the captcha response RecaptchaValidator humanValidator = new RecaptchaValidator(); humanValidator.PrivateKey = ConfigurationManager.AppSettings["RecaptchaPrivateKey"]; humanValidator.RemoteIP = this.Request.UserHostAddress; humanValidator.Challenge = this.Request.Form["recaptcha_challenge_field"]; humanValidator.Response = this.Request.Form["recaptcha_response_field"]; RecaptchaResponse humanResponse = humanValidator.Validate(); if (!humanResponse.IsValid) { Dictionary <string, object> props = new Dictionary <string, object> { { "PrivateKey", humanValidator.PrivateKey }, { "RemoteIP", humanValidator.RemoteIP }, { "Challenge", humanValidator.Challenge }, { "Response", humanValidator.Response }, { "IsValid", humanResponse.IsValid }, { "ErrorCode", humanResponse.ErrorCode } }; Logger.Write("Failed reCAPTCHA attempt", "Controller", 200, 0, TraceEventType.Verbose, "Failed reCAPTCHA attempt", props); ModelState.AddModelError("recaptcha", "reCAPTCHA failed to verify", humanValidator.Response); } } if (ViewData.ModelState.IsValid) { // Attempt to register the user MembershipCreateStatus createStatus; CosmoMongerMembershipUser newUser = (CosmoMongerMembershipUser)this.Provider.CreateUser(username, password, email, null, null, false, null, out createStatus); if (newUser != null) { return(RedirectToAction("SendVerificationCode", new RouteValueDictionary(new { username = username }))); } else { ModelState.AddModelError("_FORM", ErrorCodeToString(createStatus)); } } // If we got this far, something failed, redisplay form return(View()); }
public Task <ActionResult <RecaptchaResponse> > SampleApi(SampleData data, [FromRecaptchaResponse] RecaptchaResponse recaptchaResponse) { Console.WriteLine(recaptchaResponse); return(Task.FromResult(new ActionResult <RecaptchaResponse>(recaptchaResponse))); }
public ActionResult MultiConfigApi([FromRecaptchaResponse] RecaptchaResponse recaptchaResponse) { return(Ok(recaptchaResponse)); }
public async Task <DefaultIdentityCommandResponse> Handle(AddCompetitionEntrantCommand command) { var status = false; DefaultIdentityCommandResponse response; this._unitOfWork.Begin(); this._registrationUnitOfWork.Begin(); RecaptchaResponse recaptchaResponse = null; try { this._competition = await this._competitionRepository.GetForUpdate(command.CompetitionID); this._entrants = await this._competitionEntrantRepository.GetAll(this._competition.ID); Dictionary <int, Common.Domain.Entities.Player> newPlayers = await this._playerRepository.GetDictionary(command.Entrant.GetPlayerIDs().ToArray()); var validationContext = new ValidationContext <AddCompetitionEntrantCommand>(command); validationContext.RootContextData.Add("Competition", this._competition); this._validationResult = await this._addCompetitionEntrantCommandValidator.ValidateAsync(validationContext); if (this._validationResult.IsValid) { var competitionEntrant = this._competition.CreateEntrant(); this.AddPlayer(competitionEntrant, command.Entrant.Player1, newPlayers); this.AddPlayer(competitionEntrant, command.Entrant.Player2, newPlayers); this.AddPlayer(competitionEntrant, command.Entrant.Player3, newPlayers); this.AddPlayer(competitionEntrant, command.Entrant.Player4, newPlayers); var competitionEntrantValidationContext = new ValidationContext <CompetitionEntrant>(competitionEntrant); competitionEntrantValidationContext.RootContextData.Add("Competition", this._competition); competitionEntrantValidationContext.RootContextData.Add("CurrentEntrants", this._entrants); this._validationResult = await this._competitionEntrantValidator.ValidateAsync(competitionEntrantValidationContext); if (this._validationResult.IsValid) { await this._competitionEntrantRepository.Save(competitionEntrant); } this._unitOfWork.SoftCommit(); this._registrationUnitOfWork.SoftCommit(); status = true; response = DefaultIdentityCommandResponse.Create(this._validationResult, competitionEntrant.ID); } else { this._unitOfWork.Rollback(); this._registrationUnitOfWork.Rollback(); response = DefaultIdentityCommandResponse.Create(this._validationResult); } } catch (Exception e) { this._unitOfWork.Rollback(); this._registrationUnitOfWork.Rollback(); Console.WriteLine(e); throw; } return(response); }
public async Task <DefaultCommandResponse> Handle(AddCompetitionEntrantResultCommand command) { var status = false; DefaultCommandResponse response = new DefaultCommandResponse(); this._unitOfWork.Begin(); this._adminUnitOfWork.Begin(); RecaptchaResponse recaptchaResponse = null; try { this._competition = await this._competitionRepository.GetForUpdate(command.CompetitionID); this._entrants = await this._competitionEntrantRepository.GetAll(command.CompetitionID); var existingResults = await this._competitionEntrantResultRepository.GetAll(command.CompetitionID); if (existingResults.Count > 0) { this._validationResult.Errors.Add(new ValidationFailure("ExistingResult", "There has already been a result submitted.")); } if (this._validationResult.IsValid) { this._validationResult = await this._validator.ValidateAsync(command); } if (this._validationResult.IsValid) { foreach (var roundResult in command.Rounds) { var data = new CompetitionEntrantResult(); data.CompetitionID = this._competition.ID; data.SeasonID = this._competition.Season.ID; data.CompetitionName = this._competition.Name; data.WinnerEntrant = this._entrants.Single(x => x.ID == roundResult.Winner.EntrantID); data.LoserEntrant = this._entrants.Single(x => x.ID == roundResult.Loser.EntrantID); data.WinnerChalks = roundResult.Winner.Score.Chalks; data.WinnerHandicap = roundResult.Winner.Score.Handicap; data.LoserChalks = roundResult.Loser.Score.Chalks; data.LoserHandicap = roundResult.Loser.Score.Handicap; data.CompetitionRoundTypeID = roundResult.RoundTypeID; data.CompetitionEntrantResultStatusID = CompetitionEntrantResultStatuses.Pending; data.SetAuditFields(this._user.ID); await this._competitionEntrantResultRepository.Save(data); } this._unitOfWork.SoftCommit(); this._adminUnitOfWork.SoftCommit(); } else { this._unitOfWork.Rollback(); this._adminUnitOfWork.Rollback(); } response = DefaultCommandResponse.Create(this._validationResult); } catch (Exception e) { this._unitOfWork.Rollback(); this._adminUnitOfWork.Rollback(); Console.WriteLine(e); throw; } return(response); }
// POST: api/CaptchaVerify public ReCaptchaVerifyResponse Post([FromBody] RecaptchaResponse requestParams) { var clientIp = HttpContext.Current.Request.UserHostAddress; return(new ReCaptcha().Validate(requestParams.Response, clientIp)); }
public async Task <DefaultCommandResponse> Handle(CreateDoublesRegistrationCommand command) { var attempt = await this.StoreAttempt(command); var status = false; DefaultCommandResponse response; this._unitOfWork.Begin(); this._registrationUnitOfWork.Begin(); RecaptchaResponse recaptchaResponse = null; try { CompetitionRegistration registration = null; this._validationResult = this._validator.Validate(command); if (this._validationResult.IsValid) { await this.Load(command); RegistrationValidatorHelper.Validate(this._validationResult, this._competition); } if (this._validationResult.IsValid) { RegistrationValidatorHelper.ValidateGameFormat(this._validationResult, this._competition, GameFormats.Doubles); } if (this._validationResult.IsValid) { recaptchaResponse = await this._recaptchaService.Validate(command.Registration, "opens/registration", this._validationResult); } if (this._validationResult.IsValid) { registration = this._competition.CreateRegistration(command.Registration.Contact.Forename, command.Registration.Contact.Surname, command.Registration.Contact.EmailAddress); foreach (var player in command.Registration.Players) { var entrant = registration.CreateEntrant(this._competition); entrant.CreatePlayer(player.Player1.Forename, player.Player1.Surname); entrant.CreatePlayer(player.Player2.Forename, player.Player2.Surname); if (player.QualificationDate.HasValue) { entrant.CompetitionDateID = player.QualificationDate.Value; } } await this._competitionRegistrationRepository.Save(registration); } if (this._validationResult.IsValid) { this._unitOfWork.SoftCommit(); this._registrationUnitOfWork.SoftCommit(); await this._registrationEmailManager.SendConfirmationEmails(registration, this._competition); status = true; response = DefaultCommandResponse.Create(this._validationResult); this.StoreAttemptResponse(attempt, response); } else { this._unitOfWork.Rollback(); this._registrationUnitOfWork.Rollback(); response = DefaultCommandResponse.Create(this._validationResult); this.StoreAttemptResponse(attempt, response); } } catch (Exception e) { this._unitOfWork.Rollback(); this._registrationUnitOfWork.Rollback(); Console.WriteLine(e); throw; } finally { if (recaptchaResponse != null && recaptchaResponse.Data != null) { attempt.RecaptchaScore = recaptchaResponse.Data.Score; } attempt.Status = status; await this._competitionRegistrationAttemptRepository.Save(attempt); } return(response); }
/// <summary> /// The validate. /// </summary> public void Validate() { if (this.skipRecaptcha) { this.recaptchaResponse = RecaptchaResponse.Valid; } if (this.recaptchaResponse != null) { return; } var validator = new RecaptchaValidator { SecretKey = this.SecretKey, RemoteIP = this.Page.Request.GetUserRealIPAddress(), Response = this.Context.Request.Form["g-recaptcha-response"] }; try { this.recaptchaResponse = validator.Validate(); } catch (ArgumentNullException exception) { this.recaptchaResponse = null; this.errorMessage = exception.Message; } }
public async Task <IActionResult> Index(UserEmailDetails userEmail) { _logger.LogDebug($"{GetType().Name}.{nameof(Index)} method called..."); ViewData["ErrorMessage"] = string.Empty; RecaptchaResponse recaptcha = await _recaptcha.Validate(Request); IActionResult result = View(); if (!recaptcha.success) { ViewData["ErrorMessage"] = $"There was an error validating reCAPTCHA. Please try again!"; ModelState.AddModelError("", "There was an error validating reCAPTCHA. Please try again!"); } else { try { if (!string.IsNullOrEmpty(userEmail?.Email)) { EmailList emailListItem = new EmailList() { Id = Guid.NewGuid(), Email = userEmail.Email, IsValidated = false, DateCreated = DateTime.UtcNow }; _emailListRepository.Add(emailListItem); _unitOfWork.Save(); if (!await SendEmailMessage(this.HttpContext, emailListItem.Id, emailListItem.Email)) { ViewData["ErrorMessage"] = "Unable to send confirmation email"; } else { this.HttpContext.Session.Set("Email", Encoding.UTF8.GetBytes(userEmail.Email)); result = Redirect($"/Home/ValidateEmail/?e={userEmail?.Email}"); } } } catch (DbUpdateException ex) { _logger.LogError(ex, ex.Message); ViewData["ErrorMessage"] = "This email has already been submitted."; } catch (SqlException ex) { _logger.LogError(ex, ex.Message); if (ex.Message.ToLower().Contains("cannot insert duplicate key")) { ViewData["ErrorMessage"] = "This email has already been submitted."; } else { ViewData["ErrorMessage"] = "There was a critical failure saving to the database."; } } } return(result); }