고객별 파일 작업 공간 제공하기

File Workspace
      │
 ┌────┼───────────────┐
 ▼    ▼               ▼
Files Storage       Access
 │       │             │
 ▼       ▼             ▼
Transfer Targets   Users / Devices

작업 공간 선택
      │
      ▼
파일 저장 · 확인
      │
      ▼
전송 작업 실행
      │
      ▼
대상 장비 반영
      │
      ▼
처리 결과 확인

My Workspaces
     │
     ├── Project A
     │      ├── Files
     │      └── Transfers
     │
     ├── Media Team
     │      ├── Files
     │      └── Transfers
     │
     └── Data Analysis
            ├── Files
            └── Transfers

Workspace
    │
    ├── Upload Files
    │
    ├── Browse Files
    │
    └── Select Files
            │
            ▼
        Next Work

Select Files
      │
      ▼
Select Transfer
      │
      ▼
Run
      │
 ┌────┴────┐
 ▼         ▼
Progress   Target
 │         │
 └────┬────┘
      ▼
   Result

Organization
      │
 ┌────┼───────────────┐
 ▼    ▼               ▼
Dev  Media           Data
 │     │               │
 ▼     ▼               ▼
Storage Storage      Storage

Workspace
     │
     ├── Source Storage
     │
     ├── Transfer Flow
     │
     └── Target Devices
             │
      ┌──────┼──────┐
      ▼      ▼      ▼
   Server  Storage  System

Workspace Policy
       │
 ┌─────┼────────────┐
 ▼     ▼            ▼
Users Groups      Devices
 │       │            │
 ▼       ▼            ▼
Access  Operations  Paths
             │
             ▼
       Transfer Rules

Central Management
        │
 ┌──────┼───────────────┐
 ▼      ▼               ▼
Workspace Devices      Runs
 │        │              │
 └────────┼──────────────┘
          ▼
     Operations View

작업 공간 구성
       │
       ▼
저장 위치 연결
       │
       ▼
대상 장비 · 전송 경로 설정
       │
       ▼
사용자 · 장비 접근 정책 구성
       │
       ▼
전송 작업 실행
       │
       ▼
공간별 · 전체 운영 상태 확인

import os
import threading

import requests

BASE_URL = os.getenv("INNORIX_BASE_URL", "https://app.innorix.com").rstrip("/")


def login(email, password):
    response = requests.post(f"{BASE_URL}/api/auth/login",
                             json={"email": email, "password": password},
                             timeout=30)
    response.raise_for_status()

    # the login response nests the tokens under data.user
    user = response.json()["data"]["user"]
    return user["accessToken"], user.get("refreshToken")


def refresh(refresh_token):
    response = requests.post(f"{BASE_URL}/api/auth/token/refresh",
                             headers={"X-Refresh-Token": refresh_token},
                             timeout=30)
    response.raise_for_status()

    # the refresh response nests the tokens directly under data
    data = response.json()["data"]
    return data["accessToken"], data.get("refreshToken")

static final String BASE_URL = System.getenv()
        .getOrDefault("INNORIX_BASE_URL", "https://app.innorix.com").replaceAll("/+
quot;, "");
static final HttpClient HTTP = HttpClient.newHttpClient();
static final ObjectMapper MAPPER = new ObjectMapper();

// Returns { accessToken, refreshToken }
String[] login(String email, String password) throws Exception {
    JsonNode body = post("/api/auth/login",
            MAPPER.createObjectNode().put("email", email).put("password", password));

    // the login response nests the tokens under data.user
    JsonNode user = body.path("data").path("user");
    return new String[]{user.path("accessToken").asText(),
            user.path("refreshToken").asText(null)};
}

String[] refresh(String refreshToken) throws Exception {
    HttpRequest request = HttpRequest.newBuilder(URI.create(BASE_URL + "/api/auth/token/refresh"))
            .header("X-Refresh-Token", refreshToken)
            .POST(HttpRequest.BodyPublishers.noBody()).build();

    JsonNode data = MAPPER.readTree(
            HTTP.send(request, HttpResponse.BodyHandlers.ofString()).body()).path("data");
    return new String[]{data.path("accessToken").asText(),
            data.path("refreshToken").asText(refreshToken)};
}

const BASE_URL = (process.env.INNORIX_BASE_URL
  || "https://app.innorix.com").replace(/\/+$/, "");

async function login(email, password) {
  const response = await fetch(`${BASE_URL}/api/auth/login`, {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({ email, password }),
  });

  if (!response.ok) throw new Error(`login failed: ${response.status}`);

  // the login response nests the tokens under data.user
  const { user } = (await response.json()).data;
  return { access: user.accessToken, refresh: user.refreshToken };
}

async function refresh(refreshToken) {
  const response = await fetch(`${BASE_URL}/api/auth/token/refresh`, {
    method: "POST",
    headers: { "X-Refresh-Token": refreshToken },
  });

  if (!response.ok) throw new Error(`refresh failed: ${response.status}`);

  // the refresh response nests the tokens directly under data
  const { data } = await response.json();
  return { access: data.accessToken, refresh: data.refreshToken ?? refreshToken };
}

static readonly string BaseUrl = (Environment.GetEnvironmentVariable("INNORIX_BASE_URL")
    ?? "https://app.innorix.com").TrimEnd('/');
static readonly HttpClient Http = new();

async Task<(string Access, string Refresh)> LoginAsync(string email, string password)
{
    var response = await Http.PostAsJsonAsync(
quot;{BaseUrl}/api/auth/login",
        new { email, password });
    response.EnsureSuccessStatusCode();

    // the login response nests the tokens under data.user
    JsonNode user = JsonNode.Parse(await response.Content.ReadAsStringAsync())
        !["data"]!["user"]!;
    return (user["accessToken"]!.GetValue<string>(),
        user["refreshToken"]?.GetValue<string>());
}

async Task<(string Access, string Refresh)> RefreshAsync(string refreshToken)
{
    using var request = new HttpRequestMessage(HttpMethod.Post,
        
quot;{BaseUrl}/api/auth/token/refresh");
    request.Headers.Add("X-Refresh-Token", refreshToken);

    var response = await Http.SendAsync(request);
    response.EnsureSuccessStatusCode();

    // the refresh response nests the tokens directly under data
    JsonNode data = JsonNode.Parse(await response.Content.ReadAsStringAsync())!["data"]!;
    return (data["accessToken"]!.GetValue<string>(),
        data["refreshToken"]?.GetValue<string>() ?? refreshToken);
}

class Session:
    def __init__(self, email, password):
        self._lock = threading.Lock()
        self._access, self._refresh = login(email, password)

    @property
    def access_token(self):
        with self._lock:
            return self._access

    def renew(self):
        with self._lock:
            self._access, self._refresh = refresh(self._refresh)
            return self._access

class Session {
    private final Object lock = new Object();
    private String access;
    private String refresh;

    Session(String email, String password) throws Exception {
        String[] tokens = login(email, password);
        this.access = tokens[0];
        this.refresh = tokens[1];
    }

    String accessToken() {
        synchronized (lock) { return access; }
    }

    String renew() throws Exception {
        synchronized (lock) {
            String[] tokens = refresh(this.refresh);
            this.access = tokens[0];
            this.refresh = tokens[1];
            return this.access;
        }
    }
}

class Session {
  #access;
  #refresh;

  static async create(email, password) {
    const session = new Session();
    const tokens = await login(email, password);
    session.#access = tokens.access;
    session.#refresh = tokens.refresh;
    return session;
  }

  get accessToken() {
    return this.#access;
  }

  async renew() {
    const tokens = await refresh(this.#refresh);
    this.#access = tokens.access;
    this.#refresh = tokens.refresh;
    return this.#access;
  }
}

class Session
{
    private readonly SemaphoreSlim _lock = new(1, 1);
    private string _access;
    private string _refresh;

    public static async Task<Session> CreateAsync(string email, string password)
    {
        var session = new Session();
        (session._access, session._refresh) = await session.LoginAsync(email, password);
        return session;
    }

    public string AccessToken => _access;

    public async Task<string> RenewAsync()
    {
        await _lock.WaitAsync();
        try
        {
            (_access, _refresh) = await RefreshAsync(_refresh);
            return _access;
        }
        finally { _lock.Release(); }
    }
}

class Client:
    def __init__(self, session, workspace_id=None):
        self.session = session
        self.workspace_id = workspace_id

    def request(self, method, path, body=None, params=None, retried=False):
        headers = {
            "Content-Type": "application/json",
            "Authorization": f"Bearer {self.session.access_token}",
        }

        # when omitted the account's current workspace is used
        if self.workspace_id:
            headers["x-workspace-id"] = self.workspace_id

        response = requests.request(method, BASE_URL + path, headers=headers,
                                    json=body, params=params, timeout=30)

        if response.status_code == 401 and not retried:
            self.session.renew()
            return self.request(method, path, body, params, retried=True)

        return response

class Client {
    private final Session session;
    private final String workspaceId;

    Client(Session session, String workspaceId) {
        this.session = session;
        this.workspaceId = workspaceId;
    }

    HttpResponse<String> request(String method, String path, String body,
                                 boolean retried) throws Exception {
        HttpRequest.Builder builder = HttpRequest.newBuilder(URI.create(BASE_URL + path))
                .header("Content-Type", "application/json")
                .header("Authorization", "Bearer " + session.accessToken());

        // when omitted the account's current workspace is used
        if (workspaceId != null) builder.header("x-workspace-id", workspaceId);

        builder.method(method, body == null
                ? HttpRequest.BodyPublishers.noBody()
                : HttpRequest.BodyPublishers.ofString(body));

        HttpResponse<String> response = HTTP.send(builder.build(),
                HttpResponse.BodyHandlers.ofString());

        if (response.statusCode() == 401 && !retried) {
            session.renew();
            return request(method, path, body, true);
        }

        return response;
    }
}

class Client {
  constructor(session, workspaceId = null) {
    this.session = session;
    this.workspaceId = workspaceId;
  }

  async request(method, path, body = null, retried = false) {
    const headers = {
      "Content-Type": "application/json",
      Authorization: `Bearer ${this.session.accessToken}`,
    };

    // when omitted the account's current workspace is used
    if (this.workspaceId) headers["x-workspace-id"] = this.workspaceId;

    const response = await fetch(BASE_URL + path, {
      method,
      headers,
      body: body === null ? undefined : JSON.stringify(body),
    });

    if (response.status === 401 && !retried) {
      await this.session.renew();
      return this.request(method, path, body, true);
    }

    return response;
  }
}

class Client
{
    private readonly Session _session;
    private readonly string _workspaceId;

    public Client(Session session, string workspaceId = null)
    {
        _session = session;
        _workspaceId = workspaceId;
    }

    public async Task<HttpResponseMessage> RequestAsync(HttpMethod method, string path,
        object body = null, bool retried = false)
    {
        using var request = new HttpRequestMessage(method, BaseUrl + path);
        request.Headers.Add("Authorization", 
quot;Bearer {_session.AccessToken}");

        // when omitted the account's current workspace is used
        if (_workspaceId != null) request.Headers.Add("x-workspace-id", _workspaceId);

        if (body != null)
            request.Content = JsonContent.Create(body);

        HttpResponseMessage response = await Http.SendAsync(request);

        if (response.StatusCode == HttpStatusCode.Unauthorized && !retried)
        {
            await _session.RenewAsync();
            return await RequestAsync(method, path, body, true);
        }

        return response;
    }
}

me = api("GET", "/api/auth/me") or {}
print(me)

result = api("GET", "/api/devices", params={"page": 1, "size": 20}) or {}

if result.get("viewScope"):
    print("view scope:", result["viewScope"])

for device in result.get("devices") or []:
    print(device["deviceId"], device["name"])

JsonNode me = client.api("GET", "/api/auth/me");
System.out.println(me);

Map<String, Object> result = client.apiObj("GET", "/api/devices", null,
        Json.newObj("page", 1, "size", 20));

if (result.containsKey("viewScope")) {
    System.out.println("view scope: " + Json.str(result, "viewScope"));
}

for (Object node : Json.arrOf(result, "devices")) {
    Map<String, Object> device = Json.asObj(node);
    System.out.println(Json.str(device, "deviceId") + " " + Json.str(device, "name"));
}

const me = (await client.api("GET", "/api/auth/me")) || {};
console.log(me);

const result = (await client.api("GET", "/api/devices", null,
  { page: 1, size: 20 })) || {};

if (result.viewScope) console.log("view scope:", result.viewScope);

for (const device of result.devices || []) {
  console.log(device.deviceId, device.name);
}

JsonObject me = await client.ApiObjAsync("GET", "/api/auth/me");
Console.WriteLine(me);

JsonObject result = await client.ApiObjAsync("GET", "/api/devices", null,
    new Dictionary<string, object> { ["page"] = 1, ["size"] = 20 });

if (result["viewScope"] is not null)
    Console.WriteLine(
quot;view scope: {J.Str(result, "viewScope")}");

foreach (JsonNode node in J.ArrOf(result, "devices"))
{
    JsonObject device = J.AsObj(node);
    Console.WriteLine(
quot;{J.Str(device, "deviceId")} {J.Str(device, "name")}");
}

class WorkspaceForbidden(Exception):
    pass


def call(client, method, path, body=None, params=None):
    response = client.request(method, path, body, params)

    if response.status_code == 403:
        raise WorkspaceForbidden(path)

    payload = response.json() if response.content else {}

    if not response.ok:
        raise RuntimeError(payload.get("message") or f"HTTP {response.status_code}")

    return payload.get("data")


try:
    devices = call(client, "GET", "/api/devices")
except WorkspaceForbidden:
    devices, notice = [], "no permission to access this workspace"

class WorkspaceForbidden extends RuntimeException {
    WorkspaceForbidden(String path) { super(path); }
}

JsonNode call(Client client, String method, String path) throws Exception {
    HttpResponse<String> response = client.request(method, path, null, false);

    if (response.statusCode() == 403) throw new WorkspaceForbidden(path);

    JsonNode payload = response.body().isEmpty()
            ? MAPPER.createObjectNode() : MAPPER.readTree(response.body());

    if (response.statusCode() >= 400) {
        throw new RuntimeException(payload.path("message").asText("HTTP " + response.statusCode()));
    }

    return payload.path("data");
}

List<JsonNode> devices;
String notice = null;
try {
    devices = List.of(call(client, "GET", "/api/devices"));
} catch (WorkspaceForbidden error) {
    devices = List.of();
    notice = "이 작업 공간에 접근할 권한이 없습니다.";
}

class WorkspaceForbidden extends Error {}

async function call(client, method, path, body = null) {
  const response = await client.request(method, path, body);

  if (response.status === 403) throw new WorkspaceForbidden(path);

  const payload = response.body ? await response.json() : {};

  if (!response.ok) throw new Error(payload.message || `HTTP ${response.status}`);

  return payload.data;
}

let devices;
let notice = null;
try {
  devices = await call(client, "GET", "/api/devices");
} catch (error) {
  if (!(error instanceof WorkspaceForbidden)) throw error;
  devices = [];
  notice = "이 작업 공간에 접근할 권한이 없습니다.";
}

class WorkspaceForbidden : Exception
{
    public WorkspaceForbidden(string path) : base(path) { }
}

async Task<JsonNode> CallAsync(Client client, HttpMethod method, string path,
    object body = null)
{
    HttpResponseMessage response = await client.RequestAsync(method, path, body);

    if (response.StatusCode == HttpStatusCode.Forbidden)
        throw new WorkspaceForbidden(path);

    JsonNode payload = JsonNode.Parse(await response.Content.ReadAsStringAsync());

    if (!response.IsSuccessStatusCode)
        throw new Exception(J.Str(J.AsObj(payload), "message")
            ?? 
quot;HTTP {(int)response.StatusCode}");

    return payload?["data"];
}

JsonNode devices;
string notice = null;
try
{
    devices = await CallAsync(client, HttpMethod.Get, "/api/devices");
}
catch (WorkspaceForbidden)
{
    devices = new JsonArray();
    notice = "이 작업 공간에 접근할 권한이 없습니다.";
}

clients = {
    workspace_id: Client(session, workspace_id)
    for workspace_id in WORKSPACE_IDS
}


def collect_devices():
    result = {}

    for workspace_id, client in clients.items():
        try:
            result[workspace_id] = call(client, "GET", "/api/devices")
        except WorkspaceForbidden:
            continue

    return result

Map<String, Client> clients = new LinkedHashMap<>();
for (String workspaceId : WORKSPACE_IDS) {
    clients.put(workspaceId, new Client(session, workspaceId));
}

Map<String, JsonNode> collectDevices() {
    Map<String, JsonNode> result = new LinkedHashMap<>();

    clients.forEach((workspaceId, client) -> {
        try {
            result.put(workspaceId, call(client, "GET", "/api/devices"));
        } catch (WorkspaceForbidden ignored) {
            // skip workspaces this account cannot reach
        } catch (Exception error) {
            throw new RuntimeException(error);
        }
    });

    return result;
}

const clients = Object.fromEntries(
  WORKSPACE_IDS.map((workspaceId) => [workspaceId, new Client(session, workspaceId)]),
);

async function collectDevices() {
  const result = {};

  for (const [workspaceId, client] of Object.entries(clients)) {
    try {
      result[workspaceId] = await call(client, "GET", "/api/devices");
    } catch (error) {
      if (!(error instanceof WorkspaceForbidden)) throw error;
      // skip workspaces this account cannot reach
    }
  }

  return result;
}

var clients = WorkspaceIds.ToDictionary(
    workspaceId => workspaceId,
    workspaceId => new Client(session, workspaceId));

async Task<Dictionary<string, JsonNode>> CollectDevicesAsync()
{
    var result = new Dictionary<string, JsonNode>();

    foreach (var (workspaceId, client) in clients)
    {
        try
        {
            result[workspaceId] = await CallAsync(client, HttpMethod.Get, "/api/devices");
        }
        catch (WorkspaceForbidden)
        {
            // skip workspaces this account cannot reach
        }
    }

    return result;
}

def build_client(config):
    session = Session(config["email"], config["password"])
    return Client(session, config["workspace_id"])


clients = {name: build_client(cfg) for name, cfg in TENANTS.items()}

Client buildClient(Map<String, String> config) throws Exception {
    Session session = new Session(config.get("email"), config.get("password"));
    return new Client(session, config.get("workspaceId"));
}

Map<String, Client> clients = new LinkedHashMap<>();
for (Map.Entry<String, Map<String, String>> entry : TENANTS.entrySet()) {
    clients.put(entry.getKey(), buildClient(entry.getValue()));
}

async function buildClient(config) {
  const session = await Session.create(config.email, config.password);
  return new Client(session, config.workspaceId);
}

const clients = {};
for (const [name, cfg] of Object.entries(TENANTS)) {
  clients[name] = await buildClient(cfg);
}

async Task<Client> BuildClientAsync(TenantConfig config)
{
    Session session = await Session.CreateAsync(config.Email, config.Password);
    return new Client(session, config.WorkspaceId);
}

var clients = new Dictionary<string, Client>();
foreach (var (name, cfg) in Tenants)
{
    clients[name] = await BuildClientAsync(cfg);
}

failed = []

for name, client in clients.items():
    try:
        run_for(client)
    except Exception as error:
        failed.append((name, error))

for name, error in failed:
    print(f"{name}: {error}")

List<Map.Entry<String, Exception>> failed = new ArrayList<>();

clients.forEach((name, client) -> {
    try {
        runFor(client);
    } catch (Exception error) {
        failed.add(Map.entry(name, error));
    }
});

for (Map.Entry<String, Exception> entry : failed) {
    System.out.println(entry.getKey() + ": " + entry.getValue().getMessage());
}

const failed = [];

for (const [name, client] of Object.entries(clients)) {
  try {
    await runFor(client);
  } catch (error) {
    failed.push([name, error]);
  }
}

for (const [name, error] of failed) {
  console.log(`${name}: ${error.message}`);
}

var failed = new List<(string Name, Exception Error)>();

foreach (var (name, client) in clients)
{
    try
    {
        await RunForAsync(client);
    }
    catch (Exception error)
    {
        failed.Add((name, error));
    }
}

foreach (var (name, error) in failed)
{
    Console.WriteLine(
quot;{name}: {error.Message}");
}