Web Modeler SDK Reference

class Softyflow {}
class Collection {}
class SQLDatabase {}
class SoftyTables {}
class CustomList {}
class Report {}
class Instance {}
class Task {}
class Api {}
class Email {}
class File {}

//using SF object
let currentMode = this.SF.getSF_mode();

let currentMode = this.SF.getSF_mode();

let currentVersion = this.SF.getSF_Version();

let currentMode = this.SF.getSF_mode('SF_mode SF_version');
console.log(currentMode)
// ?SF_mode=test&SF_version=versionId

let variables = {
  "variable1": "value1",
  "variable2": 1,
  "variable3": true
}
await this.SF.startProcess('processId', variables);

let variables = {
  "variable1": "value1",
  "variable2": 1,
  "variable3": true
}
await this.SF.saveNew('interfaceId', variables);

let variables = {
  "variable1": "value1",
  "variable2": 1,
  "variable3": true
}
await this.SF.saveTask('taskId', variables);

let variables = {
  "variable1": "value1",
  "variable2": 1,
  "variable3": true
}
await this.SF.validateTask('taskId', variables);

await this.SF.getUserPendingTask('limit', 'page', 'dueDate', 'fields');

const formData = new FormData();
formData.append("profileImage", file);

let response = await SF.utils.uploadImage(formData);
// returns: { success: true, imageUrl: "/uploads/user123.png" }

let criteria = { 
  firstName: new RegExp("p", "i")
}
await this.SF.setListFromCollection('collectionId', criteria, 10, 'sort');

let results = await SF.utils.setListFromCollectionAggregation("users", [
  { $match: { age: { $gte: 18 } } },
  { $group: { _id: "$country", count: { $sum: 1 } } }
]);
// returns: [ { _id: "USA", count: 42 }, { _id: "FR", count: 18 } ]

let result = await SF.utils.setListFromReport("monthly_sales", {
  SF_createdBy: "admin@example.com",
  region: "NA"
}, 10, { by: "createdAt", direction: -1 });
// returns: [ { ... }, { ... } ]

let data = await SF.utils.setListFromReportAggregation("monthly_reports", [
  { $match: { status: "completed" } },
  { $group: { _id: "$region", total: { $sum: "$amount" } } }
]);
// returns: [ { _id: "Europe", total: 24000 }, { _id: "Asia", total: 18000 } ]

await this.SF.setListFromSQL('clientDatabaseID', "code='MMA'");

await this.SF.setListFromCustomList('CustomListID');

await this.SF.aggregateQuery('collection', '610c0343f6ebc7ddcb49cc3b', {value : "it"});

await this.SF.deleteFile('610c0343f6ebc7ddcb49cc3b');

const projects = new Projects({ mode: 'test' });

let aggregation = [
  {
    "$match": { "status": "active" }
  },
  {
    "$group": {
      "_id": "$category",
      "total": { "$sum": 1 }
    }
  }
]
let results = await projects.aggregate(aggregation);

const users = new Users();

let user = await users.findById("userId");

let criteria = { 
  firstName: new RegExp("p", "i")
}
let usersList = await users.find(criteria);

let criteria = { 
  blocked: false
}
let count = await users.count(criteria);

let body = {
  criteria: { 
    firstName: new RegExp("p", "i")
  },
  limit: 10,
  page: 0,
  sortBy: "createdAt",
  direction: -1
}
let res = await users.findAndCount(body);
let usersList = res.data;
let count = res.count;

let aggregation = [
  {
    "$match": { "firstName": new RegExp("z", "i") }
  },
  {
    "$project" : {
                    "_id": 1,
                    "firstName": 1,
                    "lastName": 1,
                    "email": 1
                  }
  }
]
let usersList = await users.aggregate([aggregation]);

await users.addRole("userId","groupId","SF_mode");

await users.removeRole("userId","groupId","SF_mode");

const groups = new Groups();

let group = await groups.findById("groupId123");

let list = await groups.find({ name: /admin/i });

let total = await groups.count({ type: "system" });

let result = await groups.findAndCount({ limit: 10, offset: 0 });

let aggregation = [
  { $match: { type: "system" } },
  { $group: { _id: "$status", total: { $sum: 1 } } }
];
let stats = await groups.aggregate(aggregation);

let users = await groups.groupUsers("groupId123");

const collection = new Collection({ id: 'collectionId', mode: this.SF_mode });

await collection.insert({ name: "name1", type : "type1" });

await collection.insertMany([{label : "IT", value : "it"}]);

let criteria = { 
  firstName: new RegExp("p", "i")
}
await collection.updateMany(criteria, [{ type : "type2" }], { upsert: true });

await collection.update("documentId", { type : "type2" });

await collection.delete("documentId");

let document = await collection.findById(id);

let body = {
  criteria: { 
    name: new RegExp("p", "i"), 
    type: "type1" 
  },
  limit: 10,
  page: 0,
  sortBy: "createdAt",
  direction: -1
}
let documents = await collection.find(body);

let count = await collection.count({ type: "type1" });

let aggregation = [
  {
    "$match": { "type": "type1" }
  },
  {
    "$project" : {
                    "_id": 1,
                    "name": 1
                  }
  }
]
let documents = await collection.aggregate([aggregation]);

const sql = new SQLDatabase({ id: '610c0343f6ebc7ddcb49cc3b', mode: this.SF_mode});

let res = await sql.findOne("client", "code='MMA'"))

let res = sql.find("client", "code='MMA'")

let count = await sql.count("client", "code='MMA'");

sql.execute("INSERT INTO client(code, intitule, representant, codepostal) VALUES('MDSX', 'holder', 'holder', 14000)")

sql.insert("client", {
    code: 'HelloWord',
    codepostal: 14000
}

sql.insertMany("client", [
  { code: '#1' },
  { code: '#2' }
])

 sql.update('client',   "code='MMA'",
    {
        code: "MQS"
    })

sql.delete("client", "id=223")

const softyTable = new SoftyTables({id: 'tableId', mode: 'test'});

const softyTable = new SoftyTables({id: 'tableId', mode: 'test'});
let row = await softyTable.findById('12345');

const softyTable = new SoftyTables({id: 'tableId', mode: 'test'});

// List all rows
let rows = await softyTable.find({});

// List with filters and pagination
let body = {
  criteria: { 
    where: { status: 'active' } 
  },
  limit: 50,
  page: 0,
  sortby: 'createdAt',
  direction: -1
}
let activeRows = await softyTable.find(body);

const softyTable = new SoftyTables({id: 'tableId', mode: 'test'});

// Count all rows
let result = await softyTable.count({});
// returns: { count: 150 }

// Count with filter
let result = await softyTable.count({ 
  criteria: { where: { status: 'active' } }
});
// returns: { count: 75 }

const softyTable = new SoftyTables({id: 'tableId', mode: 'test'});

let body = {
  criteria: { 
    where: { status: 'active' } 
  },
  limit: 10,
  page: 0,
  sortby: 'createdAt',
  direction: -1
}
let result = await softyTable.findAndCount(body);
let rows = result.data;
let count = result.count;

const softyTable = new SoftyTables({id: 'tableId', mode: 'test'});

let newRow = await softyTable.insert({
  name: 'John Doe',
  email: 'john@example.com',
  age: 30,
  status: 'active'
});

const softyTable = new SoftyTables({id: 'tableId', mode: 'test'});

let newRows = await softyTable.insertMany([
  { name: 'John Doe', email: 'john@example.com', age: 30 },
  { name: 'Jane Smith', email: 'jane@example.com', age: 25 },
  { name: 'Bob Johnson', email: 'bob@example.com', age: 35 }
]);

const softyTable = new SoftyTables({id: 'tableId', mode: 'test'});

let updated = await softyTable.update('12345', {
  status: 'inactive',
  updatedAt: new Date()
});

const softyTable = new SoftyTables({id: 'tableId', mode: 'test'});

// Update all rows where status is 'pending'
let result = await softyTable.updateMany(
  { status: 'pending' },
  { status: 'active', processedAt: new Date() }
);

const softyTable = new SoftyTables({id: 'tableId', mode: 'test'});

await softyTable.delete('12345');

const softyTable = new SoftyTables({id: 'tableId', mode: 'test'});

// Delete all inactive rows
await softyTable.deleteMany({ status: 'inactive' });

// Delete rows older than a certain date
await softyTable.deleteMany({ 
  createdAt: { $lt: new Date('2024-01-01') } 
});

const softyTable = new SoftyTables({id: 'tableId', mode: 'test'});

// Remove all rows from the table
await softyTable.clear();

const softyTable = new SoftyTables({id: 'tableId', mode: 'test'});

let options = await softyTable.getOptions();
// returns: [{ label: 'Active', value: 'active' }, { label: 'Inactive', value: 'inactive' }]

const softyTable = new SoftyTables({id: 'tableId', mode: 'test'});

// Execute a SELECT query
let results = await softyTable.execute(
  'SELECT * FROM my_table WHERE status = :status',
  {
    replacements: { status: 'active' },
    type: 'SELECT'
  }
);

// Execute a custom query
let results = await softyTable.execute(
  'UPDATE my_table SET status = "processed" WHERE created_at < NOW() - INTERVAL 30 DAY',
  { type: 'UPDATE' }
);

const softyTable = new SoftyTables({id: 'tableId', mode: 'test'});

let result = await softyTable.migrate();

const customList = new CustomList({id: 'id', mode: 'test', versionId: "vId"});

let customListData = await customList.get();

const report = new Report({id: 'id', mode: 'test'});

let aggregation = [
  {
    "$match": { "SF_status": "Running" }
  },
  { 
    "$sort": { "SF_createdAt": -1 } 
  }
]
let instances = await report.aggregate(aggregation);  //report of instances

const instance = new Instance();

let oneInstance = await instance.findById(id);

let instances = await instance.find({ status: "Running" });

let count = await instance.count({ status: "Running" });

let body = {
  criteria: { 
    status: "Running" 
  },
  limit: 10,
  page: 0,
  sortBy: "createdAt",
  direction: -1
}
let res = await instance.findAndCount(body);
let instances = res.data;
let count = res.count;

let aggregation = [
  {
    "$match": { "status": "End" }
  },
  {
    "$project" : {
                    "_id": 1,
                    "name": 1
                  }
  }
]
let instances = await instance.aggregate([aggregation]);

await instance.update(id, { status : "End" });

await instance.delete(id);

await instance.history(id, { status : "End" });

const task = new Task();

let oneTask = await task.findById(id);

let tasks = await task.find({ instanceId: "instanceId" });

let count = await task.count({ instanceId: "instanceId" });

let body = {
  criteria: { 
    status: "Running" 
  },
  assignedToConnected: true,
  limit: 10,
  page: 0,
  sortBy: "createdAt",
  direction: -1
}
let res = await task.findAndCount(body);
let tasks = res.data;
let count = res.count;

let aggregation = [
  {
    "$match": { "status": "End" }
  },
  {
    "$project" : {
                    "_id": 1,
                    "name": 1
                  }
  }
]
let tasks = await task.aggregate([aggregation]);