public async Task <IActionResult> OnPostInitializeAsync()
{
if ((await CanAdmin()) == false)
{
return(Forbid());
}
if (!ModelState.IsValid)
{
return(BadRequest());
}
HttpClient httpclient = clientFactory.CreateClient();
WorkspaceClient client = new WorkspaceClient(httpclient);
await client.InitializeAsync();
UserMetadata rawUser = new UserMetadata {
Email = "admin@localhost", Name = "Admin"
};
await _userManager.CreateAsync(rawUser, "admin");
{
UsersClient ucli = new UsersClient(httpclient);
UserMetadata user = await ucli.GetByNameAsync(rawUser.NormalizedName);
ProblemsClient pcli = new ProblemsClient(httpclient);
await pcli.CreateAsync(Helpers.Problems.GetAPlusB(user.Id));
}
return(RedirectToPage());
}
public async Task <bool> CanAdmin()
{
HttpClient httpclient = clientFactory.CreateClient();
WorkspaceClient wclient = new WorkspaceClient(httpclient);
try
{
if (await wclient.GetHasInitializedAsync())
{
if (!_signInManager.IsSignedIn(User))
{
return(false);
}
if ((await _authorizationService.AuthorizeAsync(User, Authorizations.Administrator)).Succeeded)
{
return(true);
}
else
{
return(false);
}
}
else
{
return(true);
}
}
catch
{
return(false);
}
}
public async Task TestGetWorkspace()
{
WorkspaceClient client = CreateClient();
Workspace space = await client.GetAsync();
Assert.NotNull(space.Name);
Assert.NotNull(space.WorkspaceUID);
}
/// <inheritdoc />
internal UserClient(PixivClient pixivClient) : base(pixivClient)
{
Bookmarks = new BookmarksClient(pixivClient);
BookmarkTags = new BookmarkTagsClient(pixivClient);
BrowsingHistory = new BrowsingHistoryClient(pixivClient);
Me = new MeClient(pixivClient);
Profile = new ProfileClient(pixivClient);
Workspace = new WorkspaceClient(pixivClient);
Follow = new FollowClient(pixivClient);
}
/// <summary>
/// Create a new <see cref="LanguageClient"/>.
/// </summary>
/// <param name="logger">
/// The logger to use.
/// </param>
LanguageClient(ILogger logger)
{
if (logger == null)
{
throw new ArgumentNullException(nameof(logger));
}
Log = logger.ForSourceContext <LanguageClient>();
Workspace = new WorkspaceClient(this);
Window = new WindowClient(this);
TextDocument = new TextDocumentClient(this);
_dispatcher.RegisterHandler(_dynamicRegistrationHandler);
}
/// <summary>
/// Create a new <see cref="LanguageClient"/>.
/// </summary>
/// <param name="loggerFactory">
/// The logger to use.
/// </param>
LanguageClient(ILoggerFactory loggerFactory)
{
if (loggerFactory == null)
{
throw new ArgumentNullException(nameof(loggerFactory));
}
LoggerFactory = loggerFactory;
Log = LoggerFactory.CreateLogger <LanguageClient>();
Workspace = new WorkspaceClient(this);
Window = new WindowClient(this);
TextDocument = new TextDocumentClient(this);
_dispatcher.RegisterHandler(_dynamicRegistrationHandler);
}
static async System.Threading.Tasks.Task CreateWorkspaceAndTriggerAPipelineRun(string clientId, string clientSecret, string azureTenantId, string azureSubscriptionId)
{
// Invoke the ML Client from here to test.
var credentials = GetAzureMLCredentialFromServicePrincipalWithAutoTokenRefresh(azureTenantId, clientId, clientSecret, azureSubscriptionId);
var azuremlClient = new WorkspaceClient(credentials, azureTenantId, azureSubscriptionId);
var region = Microsoft.Azure.Management.ResourceManager.Fluent.Core.Region.Create("southcentralus");
var workspaceName = "sukovalaTestSDK";
var rgName = "sukovalaTestSDKRG";
var workspace = await azuremlClient.CreateOrGetWorkspaceAsync(region, workspaceName, rgName, workspaceName, createResourceGroup : true).ConfigureAwait(false);
var attachedCompute = await azuremlClient.AttachCompute(region.Name, rgName, workspaceName, computeName : "GPU-Compute", useGPUCompute : true);
Console.WriteLine(PrettyPrintWorkspace(workspace));
Console.ReadLine();
}
public async Task <IActionResult> OnPostClearAsync()
{
if ((await CanAdmin()) == false)
{
return(Forbid());
}
if (!ModelState.IsValid)
{
return(BadRequest());
}
HttpClient httpclient = clientFactory.CreateClient();
WorkspaceClient client = new WorkspaceClient(httpclient);
await client.ClearAsync();
await _signInManager.SignOutAsync();
return(RedirectToPage());
}
public async Task <IActionResult> OnGetAsync(string id)
{
if (string.IsNullOrEmpty(id))
{
return(NotFound());
}
HttpClient httpclient = clientFactory.CreateClient();
ProblemsClient client = new ProblemsClient(httpclient);
try
{
ProblemMetadata metadata = await client.GetAsync(id);
Problem = await ProblemModel.GetAsync(metadata, httpclient, true, true);
}
catch
{
return(NotFound());
}
List <TestCaseData> samples = new List <TestCaseData>();
foreach (TestCaseMetadata s in Problem.Samples)
{
Core.DataPreview input = await client.GetSampleInputPreviewAsync(id, s.Id, int.MaxValue);
Core.DataPreview output = await client.GetSampleOutputPreviewAsync(id, s.Id, int.MaxValue);
TestCaseData td = new TestCaseData
{
Metadata = s,
Input = input.Content,
Output = output.Content,
};
samples.Add(td);
}
SampleData = samples;
CurrentUser = await _userManager.GetUserAsync(User);
EnableCode = CurrentUser != null;
if (EnableCode)
{
StringBuilder res = new StringBuilder();
WorkspaceClient wclient = new WorkspaceClient(httpclient);
IList <ProgrammingLanguage> langs;
try
{
langs = await wclient.GetSupportLanguagesAsync();
}
catch
{
langs = Array.Empty <ProgrammingLanguage>();
}
if (langs.Count == 0)
{
EnableCode = false;
}
else
{
EnableCode = true;
foreach (ProgrammingLanguage item in langs)
{
string editorId = Helper.GetEditorLanguage(item);
if (editorId == "plaintext")
{
continue;
}
res.Append("{editorId: \"" + editorId + "\", ");
switch (item)
{
// editorId for editor, lang for enum, show for selector in html
case ProgrammingLanguage.C:
res.Append("lang: \"C\", show: \"C\"},");
break;
case ProgrammingLanguage.Cpp:
res.Append("lang: \"Cpp\", show: \"C++\"},");
break;
case ProgrammingLanguage.Java:
res.Append("lang: \"Java\", show: \"Java\"},");
break;
case ProgrammingLanguage.Python:
res.Append("lang: \"Python\", show: \"Python\"},");
break;
case ProgrammingLanguage.CSharp:
res.Append("lang: \"CSharp\", show: \"C#\"},");
break;
case ProgrammingLanguage.Rust:
res.Append("lang: \"Rust\", show: \"Rust\"},");
break;
case ProgrammingLanguage.VisualBasic:
res.Append("lang: \"VisualBasic\", show: \"Visual Basic\"},");
break;
case ProgrammingLanguage.Go:
res.Append("lang: \"Go\", show: \"Go\"},");
break;
case ProgrammingLanguage.Haskell:
res.Append("lang: \"Haskell\", show: \"Haskell\"},");
break;
case ProgrammingLanguage.Javascript:
res.Append("lang: \"Javascript\", show: \"Javascript\"},");
break;
case ProgrammingLanguage.Kotlin:
res.Append("lang: \"Kotlin\", show: \"Kotlin\"},");
break;
case ProgrammingLanguage.Php:
res.Append("lang: \"Php\", show: \"PHP\"},");
break;
case ProgrammingLanguage.Ruby:
res.Append("lang: \"Ruby\", show: \"Ruby\"},");
break;
case ProgrammingLanguage.Scala:
res.Append("lang: \"Scala\", show: \"Scala\"},");
break;
}
}
}
LanguageConfig = res.ToString();
}
return(Page());
}
