mirror of
https://github.com/andrewyng/openworker.git
synced 2026-11-20 20:37:44 +00:00
Allow developers to easily build AI apps without worrying about the harness part. Bundles the Rust agent runtime as a SDK (Rust and TypeScript) for building desktop and web applications. Applications can manage a local harness or connect to an authenticated harness service on k8s with separately scaled workers and sandbox execution. The implementation is primarily contained in harness/, with deployment tooling in deploy/, Markdown guides in docs/harness/guides/, and the static documentation site in docs-site/. It does not replace the existing Python harness or migrate OpenWorker Desktop. Co-authored-by: Devika Verma <devikaverma11@gmail.com>
539 lines
21 KiB
Rust
539 lines
21 KiB
Rust
//! SQLite transactions for the shared team domain. The Store's exclusive lock
|
|
//! is the ownership boundary; this adapter is not a distributed worker database.
|
|
use super::{terminal, Event, Session, Store};
|
|
use crate::{
|
|
team_service::{self, Command, Create, Error, Transaction as TeamTransaction},
|
|
teams::{Board, Item, Member, Role},
|
|
};
|
|
use anyhow::{ensure, Context, Result};
|
|
use rusqlite::{params, Connection, OptionalExtension};
|
|
use serde_json::{json, Value};
|
|
|
|
pub(super) fn migrate(db: &Connection) -> Result<()> {
|
|
let exists: bool = db.query_row(
|
|
"SELECT EXISTS(SELECT 1 FROM sqlite_master WHERE type='table' AND name='team_version')",
|
|
[],
|
|
|r| r.get(0),
|
|
)?;
|
|
if exists {
|
|
let versions: Vec<i64> = db
|
|
.prepare("SELECT version FROM team_version")?
|
|
.query_map([], |r| r.get(0))?
|
|
.collect::<rusqlite::Result<_>>()?;
|
|
ensure!(versions == [1], "Unsupported SQLite team schema");
|
|
}
|
|
db.execute_batch("BEGIN IMMEDIATE;
|
|
CREATE TABLE IF NOT EXISTS team_version(version INTEGER NOT NULL);
|
|
INSERT INTO team_version SELECT 1 WHERE NOT EXISTS(SELECT 1 FROM team_version);
|
|
CREATE TABLE IF NOT EXISTS teams(id TEXT PRIMARY KEY,request_id TEXT UNIQUE NOT NULL,parameters TEXT NOT NULL,data TEXT NOT NULL,cursor INTEGER NOT NULL DEFAULT 0);
|
|
CREATE TABLE IF NOT EXISTS team_members(session_id TEXT PRIMARY KEY,team_id TEXT NOT NULL);
|
|
CREATE TABLE IF NOT EXISTS team_events(team_id TEXT NOT NULL,cursor INTEGER NOT NULL,kind TEXT NOT NULL,data TEXT NOT NULL,PRIMARY KEY(team_id,cursor));
|
|
CREATE TABLE IF NOT EXISTS team_commands(team_id TEXT NOT NULL,id TEXT NOT NULL,request TEXT NOT NULL,result TEXT NOT NULL,PRIMARY KEY(team_id,id));
|
|
CREATE TABLE IF NOT EXISTS team_queue(ordinal INTEGER PRIMARY KEY AUTOINCREMENT,id TEXT UNIQUE NOT NULL,session_id TEXT NOT NULL,team_id TEXT NOT NULL,item_id TEXT,assignment INTEGER,text TEXT NOT NULL,status TEXT NOT NULL,processed INTEGER NOT NULL DEFAULT 0);
|
|
CREATE TABLE IF NOT EXISTS team_cancels(session_id TEXT PRIMARY KEY,turn_id TEXT NOT NULL);
|
|
COMMIT;")?;
|
|
let versions: Vec<i64> = db
|
|
.prepare("SELECT version FROM team_version")?
|
|
.query_map([], |r| r.get(0))?
|
|
.collect::<rusqlite::Result<_>>()?;
|
|
ensure!(versions == [1], "Unsupported SQLite team schema");
|
|
Ok(())
|
|
}
|
|
fn session(db: &Connection, sid: &str) -> Result<Session> {
|
|
let raw: String = db.query_row("SELECT data FROM sessions WHERE id=?", [sid], |r| r.get(0))?;
|
|
Ok(serde_json::from_str(&raw)?)
|
|
}
|
|
fn load(db: &Connection, id: &str) -> Result<Board> {
|
|
let raw: String = db
|
|
.query_row("SELECT data FROM teams WHERE id=?", [id], |r| r.get(0))
|
|
.optional()?
|
|
.ok_or(Error::NotFound)?;
|
|
Ok(serde_json::from_str(&raw)?)
|
|
}
|
|
fn member(db: &Connection, m: &Member) -> Result<()> {
|
|
team_service::fresh_member(&session(db, &m.session_id)?, m.role)?;
|
|
let exists: bool = db.query_row(
|
|
"SELECT EXISTS(SELECT 1 FROM team_members WHERE session_id=?)",
|
|
[&m.session_id],
|
|
|r| r.get(0),
|
|
)?;
|
|
ensure!(!exists, "Session already belongs to a team");
|
|
Ok(())
|
|
}
|
|
fn record(db: &Connection, sid: &str, tid: Option<&str>, kind: &str, data: Value) -> Result<Event> {
|
|
db.execute(
|
|
"INSERT INTO events(session_id,turn_id,kind,data) VALUES(?,?,?,?)",
|
|
params![sid, tid, kind, data.to_string()],
|
|
)?;
|
|
Ok(Event {
|
|
event_id: db.last_insert_rowid(),
|
|
session_id: sid.into(),
|
|
turn_id: tid.map(str::to_owned),
|
|
kind: kind.into(),
|
|
data,
|
|
})
|
|
}
|
|
struct Tx<'a>(&'a Connection);
|
|
impl TeamTransaction for Tx<'_> {
|
|
fn event(&mut self, b: &Board, kind: &str, data: Value) -> Result<i64> {
|
|
let raw = serde_json::to_string(b)?;
|
|
ensure!(raw.len() <= 200000, "Team board storage limit reached");
|
|
let cursor: i64 =
|
|
self.0
|
|
.query_row("SELECT cursor FROM teams WHERE id=?", [&b.id], |r| r.get(0))?;
|
|
ensure!(cursor < 10000, Error::Limit);
|
|
self.0.execute(
|
|
"UPDATE teams SET data=?,cursor=? WHERE id=?",
|
|
params![raw, cursor + 1, b.id],
|
|
)?;
|
|
self.0.execute(
|
|
"INSERT INTO team_events VALUES(?,?,?,?)",
|
|
params![b.id, cursor + 1, kind, data.to_string()],
|
|
)?;
|
|
Ok(cursor + 1)
|
|
}
|
|
fn read_events(
|
|
&mut self,
|
|
b: &Board,
|
|
after: i64,
|
|
limit: i64,
|
|
item: Option<&str>,
|
|
messages: bool,
|
|
) -> Result<Value> {
|
|
let cursor: i64 =
|
|
self.0
|
|
.query_row("SELECT cursor FROM teams WHERE id=?", [&b.id], |r| r.get(0))?;
|
|
ensure!(
|
|
after >= 0 && after <= cursor && (1..=50).contains(&limit),
|
|
"Invalid team cursor or page size"
|
|
);
|
|
let mut q=self.0.prepare("SELECT cursor,kind,data FROM team_events WHERE team_id=? AND cursor>? ORDER BY cursor LIMIT ?")?;
|
|
let rows = q.query_map(params![b.id, after, limit], |r| {
|
|
Ok((
|
|
r.get::<_, i64>(0)?,
|
|
r.get::<_, String>(1)?,
|
|
r.get::<_, String>(2)?,
|
|
))
|
|
})?;
|
|
let mut next = after;
|
|
let mut events = vec![];
|
|
for r in rows {
|
|
let (seq, kind, raw) = r?;
|
|
ensure!(seq == next + 1, "Team event history incomplete");
|
|
next = seq;
|
|
let data: Value = serde_json::from_str(&raw)?;
|
|
if messages && kind != "message_posted" {
|
|
continue;
|
|
}
|
|
if item.is_some_and(|i| !i.is_empty() && data["item_id"] != i) {
|
|
continue;
|
|
}
|
|
events.push(json!({"cursor":seq,"type":kind,"data":data}));
|
|
}
|
|
ensure!(
|
|
next > after || after == cursor,
|
|
"Team event history incomplete"
|
|
);
|
|
Ok(json!({"events":events,"next_after":next,"has_more":next<cursor,"cursor":cursor}))
|
|
}
|
|
fn assignment_finished(&mut self, item: &Item) -> Result<()> {
|
|
if let (Some(sid), Some(key)) = (&item.assignee, &item.submission_id) {
|
|
let status: String = self.0.query_row(
|
|
"SELECT status FROM team_queue WHERE session_id=? AND id=?",
|
|
params![sid, key],
|
|
|r| r.get(0),
|
|
)?;
|
|
ensure!(terminal(&status),"Previous assignment is still queued or running; cancel/wait before reassigning or accepting");
|
|
}
|
|
Ok(())
|
|
}
|
|
fn current_assignment(&mut self, sid: &str, item: &Item) -> Result<()> {
|
|
let s = session(self.0, sid)?;
|
|
let t = s.turn.context("No worker turn")?;
|
|
ensure!(
|
|
item.submission_id.as_deref() == Some(&t.submission_id),
|
|
"This turn does not own the current assignment"
|
|
);
|
|
Ok(())
|
|
}
|
|
fn deliver(
|
|
&mut self,
|
|
b: &mut Board,
|
|
sid: &str,
|
|
item: Option<&Item>,
|
|
text: &str,
|
|
limit: u16,
|
|
) -> Result<String> {
|
|
ensure!(b.deliveries < 128, "Team wake budget exhausted");
|
|
let s = session(self.0, sid)?;
|
|
ensure!(
|
|
!s.closed && !s.provider_blocked,
|
|
"Recipient unavailable or provider-blocked"
|
|
);
|
|
let n: i64 = self.0.query_row(
|
|
"SELECT count(*) FROM team_queue WHERE session_id=? AND status='queued'",
|
|
[sid],
|
|
|r| r.get(0),
|
|
)?;
|
|
ensure!(n < i64::from(limit), "Recipient queue full");
|
|
let key = crate::id("delivery");
|
|
self.0.execute("INSERT INTO team_queue(id,session_id,team_id,item_id,assignment,text,status) VALUES(?,?,?,?,?,?,'queued')",params![key,sid,b.id,item.map(|i|&i.id),item.map(|i|i.assignment as i64),text])?;
|
|
b.deliveries += 1;
|
|
record(
|
|
self.0,
|
|
sid,
|
|
None,
|
|
"team_delivery_queued",
|
|
json!({"team_id":b.id,"submission_id":key,"item_id":item.map(|i|&i.id)}),
|
|
)?;
|
|
Ok(key)
|
|
}
|
|
}
|
|
pub(super) fn notice(db: &Connection, sid: &str, key: &str) -> Result<Option<Value>> {
|
|
let row = db
|
|
.query_row(
|
|
"SELECT team_id,item_id,assignment,status FROM team_queue WHERE session_id=? AND id=?",
|
|
params![sid, key],
|
|
|r| {
|
|
Ok((
|
|
r.get::<_, String>(0)?,
|
|
r.get::<_, Option<String>>(1)?,
|
|
r.get::<_, Option<i64>>(2)?,
|
|
r.get::<_, String>(3)?,
|
|
))
|
|
},
|
|
)
|
|
.optional()?;
|
|
let Some((team, item, assignment, status)) = row else {
|
|
return Ok(None);
|
|
};
|
|
let b = load(db, &team)?;
|
|
ensure!(!b.cancelled && status != "cancelled", "Team cancelled");
|
|
if let Some(id) = &item {
|
|
let i = b.items.get(id).context("Assignment missing")?;
|
|
ensure!(
|
|
i.assignee.as_deref() == Some(sid)
|
|
&& i.submission_id.as_deref() == Some(key)
|
|
&& Some(i.assignment as i64) == assignment
|
|
&& !matches!(
|
|
i.status,
|
|
crate::teams::Status::Done | crate::teams::Status::Cancelled
|
|
),
|
|
"Assignment changed"
|
|
);
|
|
ensure!(
|
|
i.dependencies
|
|
.iter()
|
|
.all(|d| b.items[d].status == crate::teams::Status::Done),
|
|
"Dependencies not complete"
|
|
);
|
|
}
|
|
Ok(Some(
|
|
json!({"team_id":team,"item_id":item,"assignment":assignment}),
|
|
))
|
|
}
|
|
pub(super) fn check(db: &Connection, s: &Session, kind: &str) -> Result<()> {
|
|
if matches!(
|
|
kind,
|
|
"model_request" | "tool_started" | "interaction_resolved"
|
|
) {
|
|
let cancelled: bool = db.query_row(
|
|
"SELECT EXISTS(SELECT 1 FROM team_cancels WHERE session_id=?)",
|
|
[&s.id],
|
|
|r| r.get(0),
|
|
)?;
|
|
ensure!(!cancelled, "Team cancellation pending");
|
|
if let Some(t) = &s.turn {
|
|
notice(db, &s.id, &t.submission_id)?;
|
|
}
|
|
}
|
|
Ok(())
|
|
}
|
|
pub(super) fn finished(db: &Connection, s: &Session) -> Result<()> {
|
|
if let Some(t) = &s.turn {
|
|
if terminal(&t.status) {
|
|
db.execute(
|
|
"UPDATE team_queue SET status=? WHERE session_id=? AND id=?",
|
|
params![t.status, s.id, t.submission_id],
|
|
)?;
|
|
}
|
|
}
|
|
Ok(())
|
|
}
|
|
impl Store {
|
|
pub fn team_create(&mut self, request: Create) -> Result<Value> {
|
|
let b = team_service::new_board(&request)?;
|
|
let raw = serde_json::to_string(&request)?;
|
|
let tx = self.db.transaction()?;
|
|
if let Some((id, old)) = tx
|
|
.query_row(
|
|
"SELECT id,parameters FROM teams WHERE request_id=?",
|
|
[&request.request_id],
|
|
|r| Ok((r.get::<_, String>(0)?, r.get::<_, String>(1)?)),
|
|
)
|
|
.optional()?
|
|
{
|
|
ensure!(old == raw, Error::Conflict);
|
|
return Ok(json!({"team_id":id,"duplicate":true}));
|
|
}
|
|
for m in b.members.values() {
|
|
member(&tx, m)?;
|
|
}
|
|
tx.execute(
|
|
"INSERT INTO teams(id,request_id,parameters,data) VALUES(?,?,?,?)",
|
|
params![b.id, request.request_id, raw, serde_json::to_string(&b)?],
|
|
)?;
|
|
for sid in b.members.keys() {
|
|
tx.execute("INSERT INTO team_members VALUES(?,?)", params![sid, b.id])?;
|
|
}
|
|
let cursor = Tx(&tx).event(
|
|
&b,
|
|
"team_created",
|
|
json!({"actor":"trusted-host","members":b.members}),
|
|
)?;
|
|
tx.commit()?;
|
|
Ok(json!({"team_id":b.id,"cursor":cursor,"duplicate":false}))
|
|
}
|
|
pub fn team_snapshot(&self, id: &str) -> Result<Value> {
|
|
let b = load(&self.db, id)?;
|
|
let c: i64 = self
|
|
.db
|
|
.query_row("SELECT cursor FROM teams WHERE id=?", [id], |r| r.get(0))?;
|
|
// Include queued deliveries and the completion outbox, even when no
|
|
// member has a current turn (e.g. waiting for credentials/capacity).
|
|
let pending: bool = self.db.query_row(
|
|
"SELECT EXISTS(SELECT 1 FROM team_queue WHERE team_id=? AND (status NOT IN ('completed','failed','cancelled','interrupted','truncated') OR (item_id IS NOT NULL AND processed=0)))",
|
|
[id], |r| r.get(0),
|
|
)?;
|
|
Ok(json!({"board":b,"cursor":c,"pending_work":pending}))
|
|
}
|
|
pub fn team_events(&self, id: &str, after: i64) -> Result<Value> {
|
|
Tx(&self.db).read_events(&load(&self.db, id)?, after, 50, None, false)
|
|
}
|
|
pub fn team_context(&self, sid: &str) -> Result<Option<crate::teams::Context>> {
|
|
let id: Option<String> = self
|
|
.db
|
|
.query_row(
|
|
"SELECT team_id FROM team_members WHERE session_id=?",
|
|
[sid],
|
|
|r| r.get(0),
|
|
)
|
|
.optional()?;
|
|
let Some(id) = id else {
|
|
return Ok(None);
|
|
};
|
|
let b = load(&self.db, &id)?;
|
|
let s = self.metadata(sid)?;
|
|
let delivery = if let Some(t) = s.turn {
|
|
self.db
|
|
.query_row(
|
|
"SELECT item_id,assignment FROM team_queue WHERE session_id=? AND id=?",
|
|
params![sid, t.submission_id],
|
|
|r| Ok((r.get::<_, Option<String>>(0)?, r.get::<_, Option<i64>>(1)?)),
|
|
)
|
|
.optional()?
|
|
} else {
|
|
None
|
|
};
|
|
Ok(Some(crate::teams::Context {
|
|
team_id: id,
|
|
role: b.members[sid].role,
|
|
session_id: sid.into(),
|
|
active_item: delivery.as_ref().and_then(|d| d.0.clone()),
|
|
assignment: delivery.and_then(|d| d.1),
|
|
}))
|
|
}
|
|
pub fn team_command(&mut self, id: &str, command: Command) -> Result<Value> {
|
|
team_service::request_id(&command.request_id)?;
|
|
let tx = self.db.transaction()?;
|
|
let mut b = load(&tx, id)?;
|
|
let key = format!("app:{}", command.request_id);
|
|
let raw = serde_json::to_string(&command)?;
|
|
if let Some((old, result)) = tx
|
|
.query_row(
|
|
"SELECT request,result FROM team_commands WHERE team_id=? AND id=?",
|
|
params![id, key],
|
|
|r| Ok((r.get::<_, String>(0)?, r.get::<_, String>(1)?)),
|
|
)
|
|
.optional()?
|
|
{
|
|
ensure!(old == raw, Error::Conflict);
|
|
return Ok(serde_json::from_str(&result)?);
|
|
}
|
|
let count: i64 = tx.query_row(
|
|
"SELECT count(*) FROM team_commands WHERE team_id=?",
|
|
[id],
|
|
|r| r.get(0),
|
|
)?;
|
|
ensure!(count < 20000, Error::Limit);
|
|
let result = if command.operation == "team_add_member" {
|
|
let m: Member = serde_json::from_value(command.arguments.clone())?;
|
|
team_service::additional_member(&b, &m)?;
|
|
member(&tx, &m)?;
|
|
tx.execute(
|
|
"INSERT INTO team_members VALUES(?,?)",
|
|
params![m.session_id, id],
|
|
)?;
|
|
b.members.insert(m.session_id.clone(), m.clone());
|
|
let cursor = Tx(&tx).event(
|
|
&b,
|
|
"member_added",
|
|
json!({"actor":"app:trusted-host","member":m}),
|
|
)?;
|
|
json!({"cursor":cursor,"member":m})
|
|
} else if command.operation == "team_cancel" {
|
|
ensure!(
|
|
command.arguments == json!({}),
|
|
"Cancel accepts no arguments"
|
|
);
|
|
b.cancelled = true;
|
|
tx.execute(
|
|
"UPDATE team_queue SET status='cancelled' WHERE team_id=? AND status='queued'",
|
|
[id],
|
|
)?;
|
|
for sid in b.members.keys() {
|
|
let s = session(&tx, sid)?;
|
|
if let Some(t) = s.turn {
|
|
if !terminal(&t.status) {
|
|
tx.execute(
|
|
"INSERT INTO team_cancels VALUES(?,?) ON CONFLICT DO NOTHING",
|
|
params![sid, t.id],
|
|
)?;
|
|
}
|
|
}
|
|
}
|
|
let cursor =
|
|
Tx(&tx).event(&b, "team_cancelled", json!({"actor":"app:trusted-host"}))?;
|
|
json!({"cursor":cursor,"cancelled":true})
|
|
} else {
|
|
team_service::operate(
|
|
&mut Tx(&tx),
|
|
&mut b,
|
|
"app:trusted-host",
|
|
Role::Lead,
|
|
&command.operation,
|
|
&command.arguments,
|
|
100,
|
|
)?
|
|
};
|
|
tx.execute(
|
|
"INSERT INTO team_commands VALUES(?,?,?,?)",
|
|
params![id, key, raw, result.to_string()],
|
|
)?;
|
|
tx.commit()?;
|
|
Ok(result)
|
|
}
|
|
pub fn team_call(&mut self, sid: &str, tid: &str, call: &Value, args: &Value) -> Result<Event> {
|
|
let mut s = self.get(sid)?;
|
|
let t = s.turn.as_ref().context("No turn")?;
|
|
ensure!(
|
|
t.id == tid && t.status == "running" && t.queue.first() == Some(call),
|
|
"Team call stale or cancelled"
|
|
);
|
|
let mut tx = self.db.transaction()?;
|
|
check(&tx, &s, "tool_started")?;
|
|
let id: String = tx.query_row(
|
|
"SELECT team_id FROM team_members WHERE session_id=?",
|
|
[sid],
|
|
|r| r.get(0),
|
|
)?;
|
|
let mut b = load(&tx, &id)?;
|
|
let role = b.members.get(sid).context("Not a member")?.role;
|
|
ensure!(s.package.team_role == Some(role), "Coworker role changed");
|
|
let name = call["name"].as_str().context("Tool name missing")?;
|
|
let output = {
|
|
let save = tx.savepoint()?;
|
|
match team_service::operate(&mut Tx(&save), &mut b, sid, role, name, args, 100) {
|
|
Ok(v) => {
|
|
save.commit()?;
|
|
v
|
|
}
|
|
Err(e) => {
|
|
drop(save);
|
|
if e.downcast_ref::<rusqlite::Error>().is_some() {
|
|
return Err(e);
|
|
}
|
|
json!({"isError":true,"message":e.to_string()})
|
|
}
|
|
}
|
|
};
|
|
let key = format!(
|
|
"agent:{sid}:{tid}:{}",
|
|
call["call_id"].as_str().context("Call ID missing")?
|
|
);
|
|
tx.execute(
|
|
"INSERT INTO team_commands VALUES(?,?,?,?)",
|
|
params![id, key, call.to_string(), output.to_string()],
|
|
)?;
|
|
if !crate::safety::hold_internal_result(&mut s, call) {
|
|
s.history.push(json!({"type":"function_call_output","call_id":call["call_id"],"output":output.to_string()}));
|
|
s.turn.as_mut().unwrap().queue.remove(0);
|
|
}
|
|
Self::append_history(&tx, &s)?;
|
|
tx.execute(
|
|
"UPDATE sessions SET data=? WHERE id=?",
|
|
params![serde_json::to_string(&s)?, sid],
|
|
)?;
|
|
let mut event = record(
|
|
&tx,
|
|
sid,
|
|
Some(tid),
|
|
"tool_finished",
|
|
crate::safety::public_internal_event(
|
|
&s,
|
|
json!({"name":name,"call_id":call["call_id"],"result":output,"execution_kind":"internal","team_id":id,"enforcement":"team-role-and-session-scope"}),
|
|
),
|
|
)?;
|
|
event.data["result"] = output;
|
|
tx.commit()?;
|
|
Ok(event)
|
|
}
|
|
pub fn team_next(&self, sid: &str) -> Result<Option<(String, String)>> {
|
|
Ok(self.db.query_row("SELECT id,text FROM team_queue WHERE session_id=? AND status='queued' ORDER BY ordinal LIMIT 1",[sid],|r|Ok((r.get(0)?,r.get(1)?))).optional()?)
|
|
}
|
|
pub fn team_tick(&mut self) -> Result<()> {
|
|
let tx = self.db.transaction()?;
|
|
let row=tx.query_row("SELECT session_id,id,team_id,status FROM team_queue WHERE item_id IS NOT NULL AND processed=0 AND status IN ('completed','failed','cancelled','interrupted','truncated') ORDER BY ordinal LIMIT 1",[],|r|Ok((r.get::<_,String>(0)?,r.get::<_,String>(1)?,r.get::<_,String>(2)?,r.get::<_,String>(3)?))).optional()?;
|
|
if let Some((sid, key, id, status)) = row {
|
|
let mut b = load(&tx, &id)?;
|
|
if let Some(item) = team_service::complete(&mut b, &sid, &key, &status) {
|
|
let lead = b.lead.clone();
|
|
let s = session(&tx, &lead)?;
|
|
let n: i64 = tx.query_row(
|
|
"SELECT count(*) FROM team_queue WHERE session_id=? AND status='queued'",
|
|
[&lead],
|
|
|r| r.get(0),
|
|
)?;
|
|
let notified = b.deliveries < 128 && n < 100 && !s.closed && !s.provider_blocked;
|
|
if notified {
|
|
Tx(&tx).deliver(
|
|
&mut b,
|
|
&lead,
|
|
None,
|
|
&team_service::completion_text(&sid, &item.id, &status),
|
|
100,
|
|
)?;
|
|
}
|
|
Tx(&tx).event(&b,"assignment_turn_finished",json!({"session_id":sid,"item":item,"status":status,"lead_notified":notified,"attention_required":!notified}))?;
|
|
}
|
|
tx.execute("UPDATE team_queue SET processed=1 WHERE id=?", [key])?;
|
|
}
|
|
tx.commit()?;
|
|
Ok(())
|
|
}
|
|
pub fn team_cancellations(&self) -> Result<Vec<(String, String)>> {
|
|
Ok(self
|
|
.db
|
|
.prepare("SELECT session_id,turn_id FROM team_cancels")?
|
|
.query_map([], |r| Ok((r.get(0)?, r.get(1)?)))?
|
|
.collect::<rusqlite::Result<_>>()?)
|
|
}
|
|
pub fn team_cancel_settled(&mut self, sid: &str, tid: &str) -> Result<()> {
|
|
self.db.execute(
|
|
"DELETE FROM team_cancels WHERE session_id=? AND turn_id=?",
|
|
params![sid, tid],
|
|
)?;
|
|
Ok(())
|
|
}
|
|
}
|