# C:\ProgramData\Indica Labs\Configuration\...\local-production.yml
identity_provider:
  clients:
    - !OidcClient/ClientCredentials
      id: integra_INDICA-CUSTOM
      scopes:
        - serviceuser
        - graphql
      require_client_secret: true
      secrets:
        - secret: cRaOX+2LW4gjrXHmlaKlag==
      implementation: !OidcImpl/HALO {}

import aiohttp, ssl, asyncio

CLIENT_ID     = "integra_INDICA-CUSTOM"
CLIENT_SECRET = "cRaOX+2LW4gjrXHmlaKlag=="
TOKEN_URL     = "https://halolink.indicalab.jp/idsrv/connect/token"

async def request_access_token():
    async with aiohttp.ClientSession() as session:
        async with session.post(TOKEN_URL, data={
            "client_id":     CLIENT_ID,
            "client_secret": CLIENT_SECRET,
            "scope":         "serviceuser graphql",
            "grant_type":    "client_credentials",
        }, ssl=ssl.SSLContext(ssl.PROTOCOL_TLS)) as resp:
            data = await resp.json()
            return data["access_token"]

var resp = await client.PostAsync(TOKEN_URL,
    new FormUrlEncodedContent(new[] {
        KeyValuePair.Create("client_id",     "integra_INDICA-CUSTOM"),
        KeyValuePair.Create("client_secret", "cRaOX+2LW4gjrXHmlaKlag=="),
        KeyValuePair.Create("scope",         "serviceuser graphql"),
        KeyValuePair.Create("grant_type",    "client_credentials"),
    }));
var json = JsonSerializer.Deserialize<TokenResponse>(await resp.Content.ReadAsStringAsync());
return json.AccessToken;

app.MapPost("/auth-proxy/graphql", async (HttpContext ctx, ISessionStore sessions, IHttpClientFactory factory) =>
{
    var session = await sessions.GetAsync(ctx);
    if (session is null || session.IsExpired)
        return Results.Json(new { error = "not_authenticated" }, statusCode: 401);

    var client = factory.CreateClient("upstream");
    var req = new HttpRequestMessage(HttpMethod.Post, "https://localhost/graphql")
    {
        Content = new StreamContent(ctx.Request.Body)
    };
    req.Headers.Authorization = new("Bearer", session.AccessToken);
    req.Headers.Add("x-requested-service-version", "^2.0");
    var upstream = await client.SendAsync(req);
    return Results.Stream(await upstream.Content.ReadAsStreamAsync(), "application/json",
        statusCode: (int)upstream.StatusCode);
});

from gql import gql, Client
from gql.transport.aiohttp import AIOHTTPTransport

transport = AIOHTTPTransport(
    url="https://halolink.indicalab.jp/graphql",
    headers={"Authorization": f"Bearer {token}"}
)

async with Client(transport=transport) as session:
    result = await session.execute(
        gql("""
        query GetImage($pk: Int!) {
          imageByPk(pk: $pk) {
            id pk location barcode tag stain width height
          }
        }
        """),
        variable_values={"pk": 1}
    )
    print(result["imageByPk"]["location"])

using System.Net.Http.Json;

var client = new HttpClient();
client.DefaultRequestHeaders.Authorization =
    new("Bearer", token);

var payload = new {
    query = @"query GetImage($pk: Int!) {
      imageByPk(pk: $pk) {
        id pk location barcode tag stain width height
      }
    }",
    variables = new { pk = 1 }
};

var resp = await client.PostAsJsonAsync(
    "https://halolink.indicalab.jp/graphql", payload);
var json = await resp.Content.ReadAsStringAsync();

result = await session.execute(
    gql("""
    query GetStudy($pk: Int!) {
      studyByPk(pk: $pk) {
        pk id name description createdTime permission
      }
    }
    """),
    variable_values={"pk": 1}
)
study = result["studyByPk"]
print(f"{study['name']} — {study['createdTime']}")

var payload = new {
    query = @"query GetStudy($pk: Int!) {
      studyByPk(pk: $pk) {
        pk id name description createdTime permission
      }
    }",
    variables = new { pk = 1 }
};
var resp = await client.PostAsJsonAsync(
    "https://halolink.indicalab.jp/graphql", payload);

result = await session.execute(
    gql("""
    query FindSettings($name: String!) {
      settings(query: {
        where: { q: { f: "savedName", pred: { op: EQ, v: $name } } }
      }) {
        edges { node { pk id algorithmName savedName } }
      }
    }
    """),
    variable_values={"name": "Shared Classifier"}
)
nodes = [e["node"] for e in result["settings"]["edges"]]

var payload = new {
    query = @"query FindSettings($name: String!) {
      settings(query: {
        where: { q: { f: ""savedName"", pred: { op: EQ, v: $name } } }
      }) {
        edges { node { pk id algorithmName savedName } }
      }
    }",
    variables = new { name = "Shared Classifier" }
};

import asyncio

async def poll_job(session, job_id):
    while True:
        result = await session.execute(
            gql("""
            query GetJobProgress($id: ID!) {
              jobById(id: $id) {
                progress { condition percentComplete errorMessage }
              }
            }
            """),
            variable_values={"id": job_id}
        )
        prog = result["jobById"]["progress"]
        print(f"{prog['condition']} — {prog['percentComplete']}%")
        if prog["condition"] in ("COMPLETE", "FAILED", "CANCELLED"):
            break
        await asyncio.sleep(5)

var payload = new {
    query = @"query GetJobProgress($id: ID!) {
      jobById(id: $id) {
        pk id settingsSavedName
        progress { condition percentComplete errorMessage }
      }
    }",
    variables = new { id = "QW5hbHlzaXNKb2I6MTIz" }
};

result = await session.execute(
    gql("""
    mutation CatalogImage($path: String!, $studyId: ID!) {
      catalogImage(input: { location: $path, studyId: $studyId }) {
        mutated { node { pk id location } }
        failed  { error }
      }
    }
    """),
    variable_values={
        "path":    r"\\server\share\images\slide001.svs",
        "studyId": "U3R1ZHk6NQ=="
    }
)
if result["catalogImage"]["failed"]:
    print("Errors:", result["catalogImage"]["failed"])
else:
    node = result["catalogImage"]["mutated"][0]["node"]
    print(f"Cataloged pk={node['pk']}")

var payload = new {
    query = @"mutation CatalogImage($path: String!, $studyId: ID!) {
      catalogImage(input: { location: $path, studyId: $studyId }) {
        mutated { node { pk id location } }
        failed  { error }
      }
    }",
    variables = new {
        path    = @"\\server\share\images\slide001.svs",
        studyId = "U3R1ZHk6NQ=="
    }
};

import math, json

# Compute pentagon vertices
ORIGIN, RADIUS = (5000, -5000), 5000
vertices = [
    [round(ORIGIN[0] + RADIUS * math.sin(2*math.pi*i/5)),
     round(ORIGIN[1] + RADIUS * math.cos(2*math.pi*i/5))]
    for i in range(5)
]
vertices.append(vertices[0])  # close ring
geometry = json.dumps({"type": "LineString", "coordinates": vertices})

# Step 1 — create layer
r1 = await session.execute(gql("""
  mutation CreateLayer($imageId: ID!) {
    createAnnotationLayer(input: { id: $imageId }) {
      mutated { node { id } }
    }
  }
"""), variable_values={"imageId": image_id})
layer_id = r1["createAnnotationLayer"]["mutated"][0]["node"]["id"]

# Step 2 — draw
await session.execute(gql("""
  mutation DrawRegion($input: DrawAnnotationRegionInput!) {
    drawAnnotationRegion(input: $input) { failed { error } }
  }
"""), variable_values={"input": {
    "layerId": layer_id, "shapeType": "POLYGON", "geometry": geometry
}})

// Step 1 — create layer
var step1 = new {
    query = @"mutation CreateLayer($imageId: ID!) {
      createAnnotationLayer(input: { id: $imageId }) {
        mutated { node { id name } }
        failed  { error }
      }
    }",
    variables = new { imageId = imageId }
};
// execute step1, extract layerId from response

// Step 2 — draw region
var step2 = new {
    query = @"mutation DrawRegion($input: DrawAnnotationRegionInput!) {
      drawAnnotationRegion(input: $input) { failed { error } }
    }",
    variables = new {
        input = new {
            layerId   = layerId,
            shapeType = "POLYGON",
            geometry  = "{\"type\":\"LineString\",\"coordinates\":[[5000,0]...]}"
        }
    }
};

result = await session.execute(
    gql("""
    mutation ScheduleJob($settingsId: ID!, $imageId: ID!) {
      scheduleAnalysis(input: {
        settingsId: $settingsId
        analysisDescriptions: [{ imageId: $imageId, fieldOfView: null }]
      }) {
        mutated { node { id pk settingsSavedName } }
        failed  { error }
      }
    }
    """),
    variable_values={
        "settingsId": settings_id,
        "imageId":    image_id,
    }
)
job_id = result["scheduleAnalysis"]["mutated"][0]["node"]["id"]
# now poll with jobById or subscribe to analysisFinishedEvent

var payload = new {
    query = @"mutation ScheduleJob($settingsId: ID!, $imageId: ID!) {
      scheduleAnalysis(input: {
        settingsId: $settingsId
        analysisDescriptions: [{ imageId: $imageId, fieldOfView: null }]
      }) {
        mutated { node { id pk settingsSavedName } }
        failed  { error }
      }
    }",
    variables = new {
        settingsId = settingsId,
        imageId    = imageId
    }
};

from gql.transport.websockets import WebsocketsTransport

transport = WebsocketsTransport(
    url="wss://halolink.indicalab.jp/graphql",
    headers={"authorization": f"bearer {token}"},
    subprotocols=[WebsocketsTransport.APOLLO_SUBPROTOCOL,]
)

async with Client(transport=transport) as session:
    async for msg in session.subscribe(gql("""
        subscription { barcodeScannedEvent { imageId } }
    """)):
        image_id = msg["barcodeScannedEvent"]["imageId"]
        # fetch full image details
        image = await session.execute(
            gql('query($id:ID!){imageById(id:$id){barcode}}'),
            variable_values={"id": image_id}
        )
        print(f"Barcode: {image['imageById']['barcode']}")

using GraphQL.Client.Http;
using GraphQL.Client.Serializer.SystemTextJson;

var graphQL = new GraphQLHttpClient(
    new GraphQLHttpClientOptions {
        EndPoint = new Uri("https://halolink.indicalab.jp/graphql"),
        WebSocketEndPoint = new Uri("wss://halolink.indicalab.jp/graphql")
    },
    new SystemTextJsonSerializer()
);
graphQL.HttpClient.DefaultRequestHeaders.Authorization =
    new("Bearer", token);

var sub = graphQL.CreateSubscriptionStream<BarcodeEvent>(
    new GraphQLRequest {
        Query = "subscription { barcodeScannedEvent { imageId } }"
    });
sub.Subscribe(msg => Console.WriteLine(msg.Data.BarcodeScannedEvent.ImageId));

import asyncio

async def on_cataloged(session):
    async for msg in session.subscribe(gql("""
        subscription { imageCatalogedEvent { imageId imageLocation } }
    """)):
        ev = msg["imageCatalogedEvent"]
        print(f"New image: {ev['imageLocation']}")

async def on_added_to_study(session):
    async for msg in session.subscribe(gql("""
        subscription { imageAddedToStudyEvent { studyId imageId } }
    """)):
        ev = msg["imageAddedToStudyEvent"]
        # update LIMS here

async def main():
    session = await create_client_session(token)
    await asyncio.gather(
        asyncio.create_task(on_cataloged(session)),
        asyncio.create_task(on_added_to_study(session)),
    )

// Run two subscriptions concurrently
var sub1 = graphQL.CreateSubscriptionStream<CatalogedEvent>(
    new GraphQLRequest {
        Query = "subscription{imageCatalogedEvent{imageId imageLocation}}"
    });
var sub2 = graphQL.CreateSubscriptionStream<StudyEvent>(
    new GraphQLRequest {
        Query = "subscription{imageAddedToStudyEvent{studyId imageId}}"
    });

sub1.Subscribe(e => Console.WriteLine($"Cataloged: {e.Data}"));
sub2.Subscribe(e => Console.WriteLine($"Added to study: {e.Data}"));