Web modeler SDK

class SoftyFlow {}
class Collection {}
class SQLDatabase {}
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 token = await SF.utils.validateCaptcha("login_form");
// returns: '03AFcWeA... (a long token string from Google)'

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 = {
  email: "email@softydev.com",
  lastName : "last name",
  firstName: "first name",
  group: [],
  metadata: {},
  ideAccess: true,
  blocked: false
}
await users.create(user);

let newData = {
  ideAccess: false
}
await users.update("userId", newData);

await users.delete("userId");

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 newGroup = await groups.create({ name: "Developers", type: "custom" });

let updated = await groups.update("groupId123", { name: "Admins Updated" });

await groups.delete("groupId123");

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

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

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: 'test' });

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 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 inctance = new Instance();

let oneInctance = await inctance.findById(id);

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

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

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

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

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

await inctance.delete(id);

await inctance.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]);

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

await task.delete(id);

await task.getNextValue("name",5,"SF_mode");

let log = await task.history("taskId123", {});

const api = new Api();

let body = {
  const myElement = document.getElementById("demo");

  function getLocation() {
    if (navigator.geolocation) {
      navigator.geolocation.getCurrentPosition(showPosition);
    } else {
      myElement.innerHTML = "Geolocation is not supported by this browser.";
    }
  }

  function showPosition(position) {
    myElement.innerHTML = "Latitude: " + position.coords.latitude +
    "<br>Longitude: " + position.coords.longitude;
  }
}
await api.invoke(body);

const email = new Email();

await email.send("assignee","subject",{"var1", "var2"},{"mailTemplate"},{"mailProvider"},"mail of user in cc", "senderMail","replyTo");

const ds = new DataSource();

let doc = await ds.findOne("users", { filter: { email: "user@example.com" } });

let docs = await ds.list("users", { filter: { active: true } });

let total = await ds.count("orders", { filter: { status: "delivered" } });

await ds.update("products", { filter: { stock: 0 } }, { restock: true });

await ds.insert("logs", { action: "login", userId: "abc123" });

await ds.insertMany("logs", [{ action: "view" }, { action: "edit" }]);

await ds.delete("sessions", { filter: { expired: true } });

await ds.execute("jobs", { action: "resetAll" });