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);
}
