# API

## appmixer.api

| **Method**                                                      | **Description**                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| --------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `appmixer.api.authenticateUser(username, password)`             | Authenticate a user to Appmixer. Note that this can be a "virtual" user that exists for the sole purpose of associating a real user of your own product to a user in Appmixer. Each user in Appmixer can have a set of flows, can run and stop flows and can see data going through their flows. The returned promise is either resolved with an object that contains `token` (which you need to set with `appmixer.set('accessToken', token)` to be able to make calls to the API backend. Or the promise is rejected with an error object. If the error object returns 403 status code (i.e. `err.response.status === 403`), the user does not exist in Appmixer. |
| `appmixer.api.signupUser(username, password)`                   | Create a new user in Appmixer. The returned promise is either resolved with an authentication object (containing the `token` property) or rejected if the sign-up fails.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| `appmixer.api.createFlow(name, [descriptor], [properties])`     | Create a new flow in Appmixer. The returned promise resolves to the ID of the newly created flow. The `properties` object can contain your own custom metadata inside the `customFields` property. This is especially useful for filtering flows based on your own custom metadata.                                                                                                                                                                                                                                                                                                                                                                                 |
| `appmixer.api.deleteFlow(flowId)`                               | Delete an existing flow identified by `flowId`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `appmixer.api.getFlow(flowId)`                                  | Get flow. The returned promise resolves to an object with the following information: `{ id, flow, name, stage, btime, mtime, thumbnail }`, where `flow` is the Flow Descriptor, `stage` is either `'running'` or `'stopped'`, `btime` is the time the flow was created ("birth" time), `mtime` is the time the flow was modified and thumbnail contains a thumbnail image (self-contained, in the [Data URI](https://en.wikipedia.org/wiki/Data_URI_scheme) format).                                                                                                                                                                                                |
| `appmixer.api.getFlows(query)`                                  | Get all flows of the user or filter them by `query`. `query` is an object with the following properties: `limit`, `offset`, `pattern` (a string to filter flows containing pattern in their names), `sort`, `projection` (allows you to exclude properties from the returned flow objects), `sharedWithPermissions` and `filter.`Example: `{ limit: 20, offset: 0, pattern: "slack", projection: "-flow,-thumbnail", sort: "mtime:-1", sharedWithPermission: "read", filter: "userId:423jfdsalfjl4234fdsa" }`                                                                                                                                                       |
| `appmixer.api.getFlowsCount(query)`                             | Get the number of all flows of the user or filter them by `query`. `query` is an object with `pattern` property that can include a string to filter flows containing a pattern in their names. Example: `{ "pattern": "dropbox" }`.                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| `appmixer.api.updateFlow(flowId, update)`                       | Update an existing flow. `update` can contain the following information: `{ flow, name, customFields }`, where `flow` is the Flow Descriptor of the flow and `customFields` is an object with your own custom metadata for this flow.                                                                                                                                                                                                                                                                                                                                                                                                                               |
| `appmixer.api.startFlow(flowId)`                                | Start a flow.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| `appmixer.api.stopFlow(flowId)`                                 | Stop a flow.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| `appmixer.api.cloneFlow(flowId)`                                | Create a copy of an existing flow. The returned promise resolves to the ID of the newly created flow.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| `appmixer.api.getUser()`                                        | Get current user. The returned promise resolves to an object with `username`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| `appmixer.api.getStores()`                                      | Get all the data stores. The returned promise resolves to an array of stores each an object with `name` and `storeId` properties.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| `appmixer.api.getStore(storeId)`                                | Get one store. The returned promise resolves to an object with `name` and `storeId` properties.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `appmixer.api.getStoreRecordsCount(query)`                      | Get the number of records in a store. `query` is an object with `storeId` and `pattern` properties where `pattern` is a string to filter records that contain the string in their keys or values.                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| `appmixer.api.getStoreRecords(query)`                           | Get store records. `query` is an object with `storeId`, `pattern` (string to search for in keys/values), `limit` , `offset` and `sort` properties. Example: `{ limit: 30, offset: 0, pattern: “foo”, sort: “updatedAt:-1", storeId: “5c6d643f4849f447eba55c1d” }`                                                                                                                                                                                                                                                                                                                                                                                                   |
| `appmixer.api.createStore(name)`                                | Create a new store. The returned promise resolves to the ID of the newly created store.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| `appmixer.api.deleteStore(storeId)`                             | Delete a store.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `appmixer.api.renameStore(storeId, newName)`                    | Rename an existing store.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| `appmixer.api.createStoreItem(storeId, key, value)`             | Create a new record in a store.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `appmixer.api.deleteStoreItems(items)`                          | Delete store items. `items` is an array of objects each having a `key` and `storeId` properties identifying the item and store from which the item should be removed.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| `appmixer.api.createAccount(params, data)`                      | Create a custom account.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| `appmixer.api.getAccounts(filter)`                              | Get a list of connected accounts of the user. `filter` is a custom query string (see the [GET /accounts](https://docs.appmixer.com/6.0/v4.3/api/accounts#get-all-accounts) for an example). The returned promise resolves to an array of objects of the form `{ accountId, name, displayName, service, icon, profileInfo }`.                                                                                                                                                                                                                                                                                                                                        |
| `appmixer.api.getComponentAccounts(componentType, componentId)` | Get a list of accounts connected to a specific component.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| `appmixer.api.getAccountFlows(accountId)`                       | Get a list of flows this account is used in. The returned promise resolves to an array of objects with `flowId` and `name` properties.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| `appmixer.api.setAccountName(accountId, newName)`               | Rename a connected account. Note that this name is displayed in the Accounts widget and also in the Inspector UI of the Designer.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| `appmixer.api.getLogs(query)`                                   | Get logs. `query` is an object of the form `{ from, size, sort, query }`. Example: `{ from: 0, size: 30, sort: "@timestamp:desc", query: "@timestamp:[2018-01-01 TO 2018-01-01]" }`. To get logs of a specific flow, use e.g. `{ from: 0, size: 30, sort: "@timestamp:desc", query: "@timestamp:[2018-01-01 TO 2018-01-01] AND +flowId:FLOW_ID" }`                                                                                                                                                                                                                                                                                                                  |
| `appmixer.api.getLog(logId, index)`                             | Get one log. `logId` and `index` are values returned from `getLogs()`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| `appmixer.api.getPeopleTasks(query)`                            | Get all tasks of the user. `query.role` can be either "approver" or "requester" and allows you to filter tasks based on the role. `query.pattern` filters returned tasks by a term that must be contained in the task title. Setting`query.secret` to either the `approverSecret` or `requesterSecret` allows you to get a list of tasks of a different user for which you have the secret (other than the one identified by the access token, i.e. the currently signed-in user).                                                                                                                                                                                  |
| `appmixer.api.getPeopleTasksCount(query)`                       | Returns the number of tasks based on the query. See `getPeopleTasks(query)` for more info.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| `appmixer.api.getPeopleTask(id)`                                | Return one task identified by `id`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| `appmixer.api.approveTask(id, [params])`                        | Approve a task identified by `id`. `params` is an optional object that can contain the `secret` property (approver secret). Having the secret allows you to approve a task of any user for which you have the secret, not just the currently signed-in user.                                                                                                                                                                                                                                                                                                                                                                                                        |
| `appmixer.api.rejectTask(id, [params])`                         | Reject a task identified by `id`. `params` is an optional object that can contain the `secret` property (approver secret). Having the secret allows you to reject a task of any user for which you have the secret, not just the currently signed-in user.                                                                                                                                                                                                                                                                                                                                                                                                          |
| `appmixer.api.getCharts()`                                      | Returns all the Insights charts of the user.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| `appmixer.api.getChart(chartId)`                                | Return one Insights chart identified by `chartId`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| `appmixer.api.deleteChart(chartId)`                             | Delete an Insights chart identified by `chartId`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| `appmixer.api.getFlowAuthentication(flowId)`                    | This request will return an object with all the components in the flow that have `auth` section with all the available accounts.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |

##
