1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99

use super::mark;
use crate::concerns::CortexInsertable;
use crate::helpers::TaskStatus;
use crate::models::{Corpus, NewTask, Service};
use crate::schema::services;
use diesel::pg::PgConnection;
use diesel::result::Error;
use diesel::*;

pub(crate) fn register_service(
  connection: &PgConnection,
  service: &Service,
  corpus_path: &str,
) -> Result<(), Error>
{
  use crate::schema::tasks::dsl::*;
  let corpus = Corpus::find_by_path(corpus_path, connection)?;
  let todo_raw = TaskStatus::TODO.raw();

  // First, delete existing tasks for this <service, corpus> pair.
  delete(tasks)
    .filter(service_id.eq(service.id))
    .filter(corpus_id.eq(corpus.id))
    .execute(connection)?;

  // TODO: when we want to get completeness, also:
  // - also erase log entries
  // - update dependencies
  let import_service = Service::find_by_name("import", connection)?;
  let entries: Vec<String> = tasks
    .filter(service_id.eq(import_service.id))
    .filter(corpus_id.eq(corpus.id))
    .select(entry)
    .load(connection)?;
  connection.transaction::<(), Error, _>(|| {
    for imported_entry in entries {
      let new_task = NewTask {
        entry: imported_entry,
        service_id: service.id,
        corpus_id: corpus.id,
        status: todo_raw,
      };
      new_task.create(connection)?;
    }
    Ok(())
  })?;
  // Finally, register a new run, completing potentially open ones for this pair
  // TODO: When we add register service capacity for the UI, extend this with owner+description
  // information
  mark::mark_new_run(
    connection,
    &corpus,
    service,
    "cli-admin".to_string(),
    "Newly registered service, initial run.".to_string(),
  )
}

pub(crate) fn extend_service(
  connection: &PgConnection,
  service: &Service,
  corpus_path: &str,
) -> Result<(), Error>
{
  use crate::schema::tasks::dsl::*;
  let corpus = Corpus::find_by_path(corpus_path, connection)?;
  let todo_raw = TaskStatus::TODO.raw();

  // TODO: when we want to get completeness, also:
  // - update dependencies
  let import_service = Service::find_by_name("import", connection)?;
  let entries: Vec<String> = tasks
    .filter(service_id.eq(import_service.id))
    .filter(corpus_id.eq(corpus.id))
    .select(entry)
    .load(connection)?;
  connection.transaction::<(), Error, _>(|| {
    for imported_entry in entries {
      let new_task = NewTask {
        entry: imported_entry,
        service_id: service.id,
        corpus_id: corpus.id,
        status: todo_raw,
      };
      new_task.create_if_new(connection)?;
    }
    Ok(())
  })
}

pub(crate) fn delete_service_by_name(
  connection: &PgConnection,
  name: &str,
) -> Result<usize, Error>
{
  delete(services::table)
    .filter(services::name.eq(name))
    .execute(connection)
}