public CodeResponse ExecuteCode(CodeRequest input) { var sw = new Stopwatch(); sw.Start(); var newInput = _fragmentService.Fix(input.Text); var assmName = Guid.NewGuid().ToIdentifierWithPrefix("a"); var implName = Guid.NewGuid().ToIdentifierWithPrefix("UserCodeImpl"); var programSource = CodeTemplate .Replace("##SOURCE##", newInput.Text) .Replace("##NS##", assmName) .Replace("##IMPLNAME##", implName); var compileResult = _hostService.StartGenerated(input.Id, programSource, assmName); return(new CodeResponse { Id = Guid.NewGuid(), Created = DateTime.Now, Diagnostics = compileResult.Diagnostics, Code = compileResult.Code }); }
public async Task <List <T> > Get <T>(CodeRequest request) where T : class { string url = _url; try { using (var httpClient = new HttpClient()) { var response = await httpClient.GetAsync(string.Format("{0}?hash={1}&CRC={2}", url, request.AndroidIDmacHash, request.CRC)); var content = response.Content.ReadAsStringAsync().Result; if (content == null) { return(null); } return(JsonConvert.DeserializeObject <List <T> >(content)); } } catch (TaskCanceledException) { throw new ExceptionHandler(); } catch (Exception ex) { var err = ex.Message; return(null); } }
public string CreateAuthCodeRequestUrl(CodeRequest request) { string url = $"{_provider.ProviderUrl}/{_provider.GetCodeMethod}?"; var props = request.GetType() .GetProperties() .Where(x => x.GetValue(request) != null); foreach (var p in props) { var attr = p.GetCustomAttributes(typeof(UrlParameterAttribute), false) .Cast <UrlParameterAttribute>() .FirstOrDefault(); if (attr != null) { url += $"{attr.ParamName}={p.GetValue(request)}&"; } else { url += $"{p.Name}={p.GetValue(request)}&"; } } return(url); }
public async Task <ActionResult> AuthorizePost(CodeRequest request) { /* * 1.判断granttype是否正确,验证APPID是否存在 * 2.验证redirecturl是否是正确 * 3.验证用户名密码是否正确 * 4.生成code,存入db * 5.跳转到用户页面 */ var validateResult = await ValidateAppSetting(request); if (!validateResult.Success) { return(Error(validateResult.Description)); } var userValidateResult = await customerDal.Login(request.username, request.password); if (!userValidateResult) { ModelState.AddModelError("", "用户名或密码错误"); return(View()); } var code = await oAuthDal.GenerateNewCode(request.appid); return(Redirect(string.Format(request.redirecturl + "?code={0}&state={1}", code, request.state))); }
public async Task <ReturnMessage <string> > ValidateAppSetting(CodeRequest request) { var application = await Task.Run(() => { var app = applicationDal.GetApplicationByAppId(request.appid); return(app); }); if (application == null) { return(ReturnMessage <string> .ErrorMsg("不合法的AppID")); } if (HttpContext.Request.UrlReferrer == null || string.IsNullOrEmpty(HttpContext.Request.UrlReferrer.Host)) { return(ReturnMessage <string> .ErrorMsg("非法的请求")); } var host = HttpContext.Request.UrlReferrer.Host.ToString(); var regex = "^(\\w+(\\.)){0,9}" + application.Host + "$"; var hostValidate = Regex.IsMatch(host, regex); if (!hostValidate) { return(ReturnMessage <string> .ErrorMsg("请在APP设置的域名内使用OAuth")); } var redircturlValidate = Regex.IsMatch(request.redirecturl, regex); if (!redircturlValidate) { return(ReturnMessage <string> .ErrorMsg("redirect url不合法")); } return(ReturnMessage <string> .SuccessMsg("")); }
public async Task <IActionResult> VerifySmsAsync( [FromBody] CodeRequest model, [ModelBinder(typeof(CountryModelBinder))] string country, [FromHeader(Name = "User-Agent")] string agent, CancellationToken token) { var user = await _signInManager.GetTwoFactorAuthenticationUserAsync(); if (user == null) { _logger.Error("VerifySmsAsync We can't identify the user"); return(Unauthorized()); } var v = await _userManager.ChangePhoneNumberAsync(user, user.PhoneNumber, model.Number); if (v.Succeeded) { agent = agent.Substring(0, Math.Min(agent.Length, 255)); return(await FinishRegistrationAsync(user, country, model.FingerPrint, agent, token)); } _logger.Warning($"userid: {user.Id} is not verified reason: {v}"); ModelState.AddIdentityModelError(v); return(BadRequest(ModelState)); }
public async Task <string> GetCodeResultAsync(string code) { using (var client = new HttpClient()) { HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Post, new Uri(API_URL)); request.Headers.Add("Referer", API_HEADER); var codeSnippet = code; var codeInput = new CodeRequest { Language = "csharp", CaptureStats = false, Sources = new string[1] }; codeInput.Sources[0] = codeSnippet; var request_content = JsonConvert.SerializeObject(codeInput); request.Content = new StringContent(request_content, Encoding.UTF8, "application/json"); client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json")); HttpResponseMessage response = await client.SendAsync(request); var responseString = await response.Content.ReadAsStringAsync(); var codeOutput = JsonConvert.DeserializeObject <CodeResponse>(responseString); return(codeOutput.Output[0] ?? string.Empty); } }
public async void Handles_Endless_Queries() { var id = Guid.NewGuid(); var code = @" var x = 42; while (true) { System.Threading.Thread.Sleep(1000); x.Dump(); } "; var request = new CodeRequest { Text = code, Id = id }; var json = JsonConvert.SerializeObject(request); var res = await _client .PostAsync(EndpointAddress, new StringContent(json)) ; // default timeout is 5 secs var msgs = GetMessages(); var jsonRes = await res.Content.ReadAsStringAsync(); var output = JsonConvert.DeserializeObject <CodeResponse>(jsonRes); Assert.Equal(StatusCode.Ok, output.Code); Assert.True(1 < msgs.Count(), "More then 1 msg expected"); Assert.True(msgs.Count() < 10, "Less than 10 msgs expected"); }
// GET: OAuth2 public async Task <ActionResult> Authorize(CodeRequest request) { var validateResult = await ValidateAppSetting(request); if (validateResult.Success) { return(View()); } return(Error(validateResult.Description)); }
public override Task <SystemCountryCodePayload> ReadSystemCountryCode(CodeRequest request, ServerCallContext context) { var poco = _logic.Get(request.Code); return(new Task <SystemCountryCodePayload>(() => new SystemCountryCodePayload() { Code = poco.Code, Name = poco.Name })); }
public async void Returns_Expected_Template_For_Code_Sample() { var request = new CodeRequest { Id = Guid.NewGuid(), Text = "" }; var json = JsonConvert.SerializeObject(request); var res = await _client.PostAsync(EndpointAddress, new StringContent(json)); var jsonRes = await res.Content.ReadAsStringAsync(); var output = JsonConvert.DeserializeObject <TemplateResponse>(jsonRes); // insert some legal code at the offsets returned var userCode = "var x = 10;"; var modifiedTemplate = output.Template.InsertTextAt(userCode, output.LineOffset, output.ColumnOffset); // setup emitting the source text to check for syntax and other errors var syntaxTree = CSharpSyntaxTree.ParseText(modifiedTemplate); var references = new ReferenceProvider().GetReferences(); var compilation = CSharpCompilation.Create(Guid.NewGuid().ToIdentifierWithPrefix("test")) .WithOptions(new CSharpCompilationOptions(outputKind: OutputKind.DynamicallyLinkedLibrary)) .WithReferences(references) .AddSyntaxTrees(new SyntaxTree[] { syntaxTree }); // emit var stream = new MemoryStream(); var compilationResult = compilation.Emit(stream, options: new EmitOptions()); var errors = compilationResult.Diagnostics.Where(x => x.Severity == DiagnosticSeverity.Error); foreach (var err in errors) { Console.WriteLine("err: {0}", err.GetMessage()); } // check we had zero errors from all this Assert.Empty(errors); // check the template looks like expected Assert.Equal(StatusCode.Ok, output.Code); Assert.NotNull(output.Namespace); var nodes = syntaxTree.GetRoot().DescendantNodes(); Assert.NotEmpty(nodes.OfType <NamespaceDeclarationSyntax>().Where(x => x.Name.ToString() == output.Namespace)); // check that the contents of the usercode method contains the snippet inserted at the returned offsets var mb = nodes.OfType <MethodDeclarationSyntax>() .Single(x => x.Identifier.ToString().StartsWith("UserCodeImpl")); Assert.Contains(userCode, mb.Body.ToString()); }
public async Task <ServerResponse <Transaction> > CodeAction(CodeRequest request) { var currentSynchronizationContext = SynchronizationContext.Current; try { SynchronizationContext.SetSynchronizationContext(new OperationContextSynchronizationContext(InnerChannel)); return(await WrapperTS(Channel.CodeAction, request)); } finally { SynchronizationContext.SetSynchronizationContext(currentSynchronizationContext); } }
public void RoundTrip() { CodeRequest[] requests = new CodeRequest[] { new CodeRequest(TestItem.KeccakA, TestItem.KeccakB), new CodeRequest(TestItem.KeccakC, TestItem.KeccakD), }; GetContractCodesMessage message = new GetContractCodesMessage(requests, 774); GetContractCodesMessageSerializer serializer = new GetContractCodesMessageSerializer(); SerializerTester.TestZero(serializer, message); }
public async void Template_Contains_User_Text() { var request = new CodeRequest { Id = Guid.NewGuid(), Text = "hej mor" }; var json = JsonConvert.SerializeObject(request); var res = await _client.PostAsync(EndpointAddress, new StringContent(json)); var jsonRes = await res.Content.ReadAsStringAsync(); var output = JsonConvert.DeserializeObject <TemplateResponse>(jsonRes); Assert.Contains(request.Text, output.Template); }
public async Task <HttpResponseMessage> Delete(CodeRequest request) { string url = string.Format("{0}?id={1}&hash={2}&CRC={3}", _url, request.TypeDeviceID, request.AndroidIDmacHash, request.CRC); try { using (var httpClient = new HttpClient()) { return(await httpClient.DeleteAsync(url)); } } catch (TaskCanceledException) { throw new ExceptionHandler(); } }
public CodeStatus GetCodeStatus(CodeRequest cr) { if (cr.Code.Equals("12345")) { CodeStatus cs = new CodeStatus { status = "winner", prize = "nothing" }; return(cs); } CodeStatus losingCs = new CodeStatus { status = "loser" }; return(losingCs); }
public async Task <HttpResponseMessage> Put(CodeRequest req) { string url = string.Format("{0}?id={1}&hash={2}&CRC={3}", _url, req.TypeDeviceID, req.AndroidIDmacHash, req.CRC); try { using (var httpClient = new HttpClient()) { HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Put, url); return(await httpClient.SendAsync(request)); } } catch (TaskCanceledException) { throw new ExceptionHandler(); } }
public async Task <IActionResult> CSharp(Code code) { string output = code.csx; var apiURL = "https://www.microsoft.com/net/api/code"; using (var client = new HttpClient()) { HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Post, new Uri(apiURL)); request.Headers.Add("Referer", "https://www.microsoft.com/net"); var codeSnippet = code.csx; var codeInput = new CodeRequest { language = "csharp", captureStats = false, sources = new string[1] }; codeInput.sources[0] = codeSnippet; var request_content = JsonConvert.SerializeObject(codeInput); request.Content = new StringContent(request_content, Encoding.UTF8, "application/json"); client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json")); HttpResponseMessage response = await client.SendAsync(request); var responseString = await response.Content.ReadAsStringAsync(); var codeOutput = JsonConvert.DeserializeObject <CodeResponse>(responseString); //We need to account for multiline responses if (codeOutput.Output.Length == 1) { code.output = codeOutput.Output[0]; } if (codeOutput.Output.Length > 1) { foreach (var line in codeOutput.Output) { code.output += line + "<br />"; } } } return(View(code)); }
/// <summary> /// For Slave device save Deivec and get generated CodeA /// </summary> /// <param name="request"></param> /// <returns></returns> public CodeResponce Post(CodeRequest request) { if (request == null) { return(null); } //GetCodeA int code = 0; int result = 0; int.TryParse(GetCodeA(new Device { TypeDeviceID = (int)request.TypeDeviceID, AndroidIDmacHash = request.AndroidIDmacHash, }), out code); if (code < 100000) { result = code; } return(new CodeResponce { Code = code, Hash = request.AndroidIDmacHash + request.CRC, ResultCode = result }); }
public TemplateResponse GetTemplate(CodeRequest input) { Logger.Debug("{1}: {0}", JsonConvert.SerializeObject(input), input.Id); var srcToken = "##SOURCE##"; var assmName = Guid.NewGuid().ToIdentifierWithPrefix("a"); var implName = Guid.NewGuid().ToIdentifierWithPrefix("UserCodeImpl"); var userText = input.Text ?? string.Empty; LinePosition position; var src = CodeTemplate .Replace("##NS##", assmName) .Replace("##IMPLNAME##", implName) .ReplaceToken(srcToken, userText, out position); return(new TemplateResponse { Template = src, Namespace = assmName, LineOffset = position.Line, ColumnOffset = position.Character, }); }
public async Task <IActionResult> JoinWithCode(CodeRequest request) { if (request.Code != null) { var teamId = await _teamService.JoinWithCode(request.Code); if (teamId.IsEmpty) { return(NotFound(new ErrorResponse { Message = "Could not join to team!" })); } return(Ok(new TeamIdResponse { TeamId = teamId.Value })); } return(BadRequest(new ErrorResponse { Message = "Code can not be empty!" })); }
public async void Returns_Expected_Data_For_Code_Sample(Guid id, string code, Message[] expectedMsgs) { var request = new CodeRequest { Text = code, Id = id }; var json = JsonConvert.SerializeObject(request); var res = await _client .PostAsync(EndpointAddress, new StringContent(json)) ; var msgs = GetMessages(); var jsonRes = await res.Content.ReadAsStringAsync(); var output = JsonConvert.DeserializeObject <CodeResponse>(jsonRes); Assert.Equal(StatusCode.Ok, output.Code); foreach (var expected in expectedMsgs) { msgs.Single(x => { return(x.Id == expected.Id && x.Type == expected.Type && CompareValueLists(expected.Values, x.Values)); }); } }
public static CodeRequest RequestCode(Service service, string number, string codeHash, TelegramSettings settings, bool call) { try { service.DebugPrint("Requesting code..."); var transportConfig = new TcpClientTransportConfig(settings.NearestDcIp, settings.NearestDcPort); using (var client = new TelegramClient(transportConfig, new ConnectionConfig(settings.AuthKey, settings.Salt), AppInfo)) { TelegramUtils.RunSynchronously(client.Connect()); if (!call) { try { var result = TelegramUtils.RunSynchronously(client.Methods.AuthSendCodeAsync(new AuthSendCodeArgs { PhoneNumber = number, SmsType = 0, ApiId = AppInfo.ApiId, ApiHash = "f8f2562579817ddcec76a8aae4cd86f6", LangCode = PhoneBook.Language })) as AuthSentCode; return(new CodeRequest { Registered = result.PhoneRegistered, CodeHash = result.PhoneCodeHash, }); } catch (RpcErrorException ex) { var error = (RpcError)ex.Error; var cr = new CodeRequest(); var response = CodeRequest.Type.Failure; switch (error.ErrorCode) { case 400: cr.Response = CodeRequest.Type.NumberInvalid; break; default: cr.Response = CodeRequest.Type.Failure; break; } return(cr); } } var result2 = (bool)TelegramUtils.RunSynchronously(client.Methods.AuthSendCallAsync(new AuthSendCallArgs { PhoneNumber = number, PhoneCodeHash = codeHash, })); return(new CodeRequest { Response = result2 ? CodeRequest.Type.Success : CodeRequest.Type.Failure }); } } catch (Exception ex) { service.DebugPrint("Error in CodeRequest: " + ex); } return(null); }
public async Task <ServerResponse <Transaction> > CodeAction(CodeRequest request) { return(await OnlyRunOnIntranet(() => _cl.CodeAction(request))); }
public static CodeRequest RequestCode(Service service, string number, string codeHash, TelegramSettings settings, bool call) { try { service.DebugPrint("Requesting code..."); var transportConfig = new TcpClientTransportConfig(settings.NearestDcIp, settings.NearestDcPort); using (var client = new TelegramClient(transportConfig, new ConnectionConfig(settings.AuthKey, settings.Salt), AppInfo)) { TelegramUtils.RunSynchronously(client.Connect()); if (!call) { try { var result = TelegramUtils.RunSynchronously(client.Methods.AuthSendCodeAsync(new AuthSendCodeArgs { PhoneNumber = number, SmsType = 0, ApiId = AppInfo.ApiId, ApiHash = "f8f2562579817ddcec76a8aae4cd86f6", LangCode = PhoneBook.Language })) as AuthSentCode; return new CodeRequest { Registered = result.PhoneRegistered, CodeHash = result.PhoneCodeHash, }; } catch (RpcErrorException ex) { var error = (RpcError)ex.Error; var cr = new CodeRequest(); var response = CodeRequest.Type.Failure; switch (error.ErrorCode) { case 400: cr.Response = CodeRequest.Type.NumberInvalid; break; default: cr.Response = CodeRequest.Type.Failure; break; } return cr; } } var result2 = (bool)TelegramUtils.RunSynchronously(client.Methods.AuthSendCallAsync(new AuthSendCallArgs { PhoneNumber = number, PhoneCodeHash = codeHash, })); return new CodeRequest { Response = result2 ? CodeRequest.Type.Success : CodeRequest.Type.Failure }; } } catch (Exception ex) { service.DebugPrint("Error in CodeRequest: " + ex); } return null; }
public static CodeRequest RequestCode(Service service, string number, string codeHash, TelegramSettings settings, bool reVerify) { try { service.DebugPrint("Requesting code..."); var transportConfig = new TcpClientTransportConfig(settings.NearestDcIp, settings.NearestDcPort); using (var client = new TelegramClient(transportConfig, new ConnectionConfig(settings.AuthKey, settings.Salt), AppInfo)) { TelegramUtils.RunSynchronously(client.Connect()); try { AuthSentCode result; if (reVerify) { result = TelegramUtils.RunSynchronously(client.Methods.AuthResendCodeAsync(new AuthResendCodeArgs { PhoneNumber = number, PhoneCodeHash = codeHash })) as AuthSentCode; } else { result = TelegramUtils.RunSynchronously(client.Methods.AuthSendCodeAsync(new AuthSendCodeArgs { PhoneNumber = number, ApiId = AppInfo.ApiId, ApiHash = "f8f2562579817ddcec76a8aae4cd86f6", })) as AuthSentCode; } return(new CodeRequest { Registered = result.PhoneRegistered != null ? true : false, CodeHash = result.PhoneCodeHash, CurrentType = GetAuthSentType(result.Type), NextType = GetAuthType(result.NextType) }); } catch (RpcErrorException ex) { Utils.DebugPrint(">>>> Send code failure " + ObjectDumper.Dump(ex)); var error = (RpcError)ex.Error; var cr = new CodeRequest(); var response = CodeRequest.Type.Failure; switch (error.ErrorCode) { case 400: cr.Response = CodeRequest.Type.NumberInvalid; break; case 303: var newDcId = GetDcId(error.ErrorMessage); cr.Response = CodeRequest.Type.Migrate; cr.MigrateId = newDcId; break; default: cr.Response = CodeRequest.Type.Failure; break; } return(cr); } return(new CodeRequest { Response = CodeRequest.Type.Success }); } } catch (Exception ex) { service.DebugPrint("Error in CodeRequest: " + ex); } return(null); }