A feed of the latest and greatest ForgeBox package entries https://www.forgebox.io/ Ortus Solutions, Corp (www.ortussolutions.com) http://www.rssboard.org/rss-specification FeedGenerator Mon, 13 Apr 2026 03:23:07 GMT Mon, 13 Apr 2026 03:23:07 GMT # Preside JS Modern A Preside CMS extension that replaces legacy jQuery and Bootstrap JavaScript with modern, lightweight alternatives while maintaining full API compatibility. ## Overview Preside's admin interface relies on jQuery 2.x and Bootstrap 3.x. This extension provides drop-in replacements using Preside's Sticker asset management system: | Legacy Library | Replacement | Description | |----------------|-------------|-------------| | jQuery 2.2.5 | **JQNext** | jQuery 2.x API compatible, modern ES6+ internals | | Bootstrap 3 JS | **SandalJS** | Bootstrap 3 API compatible, powered by JQNext | ## How It Works Preside uses Sticker for asset management where each asset has a unique ID. This extension registers assets using the **same IDs** as core Preside: - `/js/admin/lib/jquery/` → JQNext (replaces jQuery) - `/js/admin/lib/bootstrap/` → SandalJS (replaces Bootstrap JS) When loaded, Sticker's override mechanism ensures the modern libraries are used throughout the admin interface. All existing Preside JavaScript continues to work without modification. ## Benefits ### Smaller Bundle Size Both libraries leverage native browser APIs, resulting in significantly smaller file sizes. ### Modern Browser APIs - **Web Animation API** - Smooth 60fps animations - **Fetch API** - Modern AJAX with Promises - **WeakMap** - Memory-efficient data storage - **Intersection Observer** - Efficient scroll-based features ### Full Compatibility - jQuery 2.x API - All methods, selectors, and patterns work unchanged - jQuery UI 1.11.x - Full widget factory support - Bootstrap 3 components - Modal, Dropdown, Tooltip, Collapse, etc. - Preside-specific - `window.presideJQuery` automatically set ### Future-Proof No legacy IE polyfills, ES6+ classes, native Promises, tree-shakeable modules. ## Modern + Legacy: Best of Both Worlds JQNext enables Preside developers to gradually adopt modern JavaScript patterns while maintaining full compatibility with existing jQuery-based code. This means you can: **Mix Modern and Legacy Patterns** ```javascript // Legacy jQuery patterns continue to work $('.widget').on('click', function() { $(this).fadeIn(); }); // Modern patterns work alongside $('.widget').on('click', async function() { const response = await fetch('/api/data'); const data = await response.json(); $(this).html(data.content); }); ``` **Use Native Promises with jQuery AJAX** ```javascript // JQNext's $.ajax() returns a native Promise-compatible object const data = await $.getJSON('/api/endpoint'); // Or use Fetch directly alongside jQuery DOM manipulation const response = await fetch('/api/endpoint'); $('.container').html(await response.text()); ``` **Leverage Modern APIs in Existing Code** ```javascript // JQNext uses WeakMap internally, preventing memory leaks in long-running SPAs $('.dynamic-content').data('instance', complexObject); // No need to manually clean up - garbage collected automatically // Animation uses Web Animation API for better performance $('.element').animate({ opacity: 0.5 }, 300); // Runs on compositor thread, won't block main thread ``` **Incremental Migration Path** - Start with this extension as a drop-in replacement - Write new code using modern JavaScript patterns - Existing Preside admin customisations continue to work - Gradually refactor legacy code as time permits ## Installation ```bash box install preside-ext-jsmodern ``` ## Requirements - Preside CMS 10.x or later - Modern browsers (Chrome 60+, Firefox 55+, Safari 12+, Edge 79+) ## Included Libraries ### JQNext Full jQuery 2.x API compatibility: - Selectors including `:visible`, `:hidden`, `:eq(n)`, etc. - DOM traversal and manipulation - Events with delegation and namespacing - Effects: `fadeIn()`, `slideUp()`, `animate()`, etc. - AJAX: `$.ajax()`, `$.get()`, `$.post()` - Utilities: `$.extend()`, `$.Deferred()`, etc. - jQuery UI widget factory support ### SandalJS Bootstrap 3 JavaScript components: - Modal, Dropdown, Tooltip, Popover - Tab, Collapse, Alert, Button - Carousel, Scrollspy, Affix - Full data-attribute API support ## Browser Support Modern browsers with ES6+ support. Legacy IE is intentionally not supported. ## License MIT ## Credits - **JQNext** by Pixl8 Group Limited https://github.com/pixl8/JQNext - **SandalJS** by Pixl8 Group Limited https://github.com/pixl8/SandalJS - Built for [Preside CMS](https://www.preside.org/) https://forgebox.io/view/preside-ext-jsmodern Fri, 10 Apr 2026 21:30:35 GMT preside-extensions https://forgebox.io/view/preside-ext-jsmodern # SAML2 Single Sign On for Preside [](https://travis-ci.org/pixl8/preside-ext-saml2-sso) This extension provides single sign on for Preside applications using [SAML2](https://en.wikipedia.org/wiki/SAML_2.0). In its current form, it allows your website, for front-end website users, to be used as an Identity Provider (IDP) and for the Preside application (either front or backend) to act as a Service Provider (SP) with an external IDP. See the [Wiki](https://github.com/pixl8/preside-ext-saml2-sso/wiki) for full documentation. https://forgebox.io/view/preside-ext-saml2-sso Wed, 22 Oct 2025 08:54:04 GMT preside-extensions https://forgebox.io/view/preside-ext-saml2-sso # PresideCMS Extension: Admin Dashboards This is an extension for PresideCMS that provides APIs and a methodolgy for creating user customizable dashboard interfaces in Preside admin. ## Installation Install with: ```box install preside-ext-admin-dashboards``` ## User stories The following user stories describe the functionality of this extension: * As an admin user, I want to be able to view a dashboard with multiple widgets so that I can get an overview of a particular data scenario(s) * As an admin administrator, I want to be able to limit access to particular dashboard widgets so that I can protect sensitive data and functionality * As an admin user, I want to be able to configure widgets and have my configuration persisted so that I can customize my view of a dashboard ## Rendering a dashboard Admin dashboards are made up of "widgets" that a user can configure to show stats, summaries, etc. To render a dashboard, you can use the `renderAdminDashboard()` helper, providing an _arbitrary but unique_ dashboard ID that identifies a unique dashboard, an array of widget IDs and an optional column count (default 2, valid options are 1, 2, 3 or 4): ```cfc #renderAdminDashboard( dashboardId = "mainAdminDashboard" , widgets = [ "latestNews", "topStories", "yourTasks" ] , columnCount = 3 )# ``` ### Passing instance specific data You may have a case where: 1. You have multiple instances of the same dashboard, but with different instance data 2. You have multiple instances of the same widget within your dashboard, but with different hard coded config values For this you can use the `contextData` arg to `renderAdminDashboard` and/or individual widgets: ```cfc // example 1 #renderAdminDashboard( dashboardId = "mainAdminDashboard" , widgets = [ "latestNews", "topStories", "yourTasks" ] , columnCount = 3 , contextData = { recordId=prc.recordId } )# // example 2 #renderAdminDashboard( dashboardId = "mainAdminDashboard" , columnCount = 3 , widgets = [ { id="stats", contextData={ object="event" }, ajax=false, configInstanceId="event" }, { id="stats", contextData={ object="news" }, ajax=false, configInstanceId="news" } ] )# ``` Notice how, in example 2, each widget is a `struct`. Widgets can either be passed as a simple string to represent the widget ID, or as a struct with the following keys: * `id`: The widget ID * `contextData`: Widget specific struct of data that will be passed to the widget render * `ajax`: Whether or not to use ajax to render the widget (default true) * `configInstanceId`: String to identify, along with the dashboard ID and user ID, a unique set of configuration options for the widget ## Creating dashboard widgets An admin dashboard widget is created in three parts; a handler for rendering a widget and running any custom permissioning logic, an i18n properties file for labels and icons, and a preside form for providing any user editable config for the widget. For example, if you had a widget called `latestNews`, you would have the following files: ``` /i18n/admin/admindashboards/widget/latestNews.properties /forms/admin/admindashboards/widget/latestNews.xml /handlers/admin/admindashboards/widget/LatestNews.cfc ``` And they might look like this: ```properties // /i18n/admin/admindashboards/widget/latestNews.properties title=Latest news description=See below for latest news articles for you to read. iconClass=fa-newspaper orange field.category.title=Category ``` ```xml // /forms/admin/admindashboards/widget/latestNews.xml ``` ```cfc // /handlers/admin/admindashboards/widget/LatestNews.cfc component { // You MUST implement a render() method with which to render // the content private string function render( event, rc, prc, args={} ) { args.latestNews = getModel( "newsService" ).getLatestNews( category = args.config.category ?: "" // args.config is the user configured config from the config form , featured = IsTrue( args.contextData.featured ?: "" ) // args.contextData is any data passed in renderAdminDashboard() call ); return renderView( view="/admin/admindashboards/widgets/latestNews", args=args ); } // An OPTIONAL permissions checking handler that returns true or false private boolean function hasPermission( event, rc, prc, args={} ) { return true; } // An OPTIONAL handler to render additional top right 'menu items' in the widget private string function additionalMenu( event, rc, prc, args={} ) { var addLink = event.buildAdminLink( objectName="news_item", operation="addRecord" ); return ' '; } } ``` ## What's next We've created this extension with what we feel is the bare minimum functionality for a first release. Obvious features that are lacking: * Ability for a dashboard to have _optional_ widgets that users can add to a dashboard if they want * Ability for a dashboard user to drag items around and configure them the way they like * Ability for a dashboard user to save a dashboard configuration and share it with other users If you're keen on helping out with ideas or code, do get in touch! https://forgebox.io/view/preside-ext-admin-dashboards Wed, 07 Jan 2026 04:49:37 GMT preside-extensions https://forgebox.io/view/preside-ext-admin-dashboards # Multi Select Form Control for Preside ## Overview This extension provides multi select form control with AJAX filtering functionality binding to Preside data objects. See [Wiki](https://github.com/pixl8/preside-ext-multiselect/wiki) for complete usage documentation. ## Installation Install the extension to your application via either of the methods detailed below (Git submodule / CommandBox) and then enable the extension by opening up the Preside developer console and entering: ``` extension enable preside-ext-multiselect reload all ``` ### CommandBox (box.json) method From the root of your application, type the following command: ``` box install preside-ext-multiselect ``` ### Git Submodule method From the root of your application, type the following command: ``` git submodule add https://github.com/pixl8/preside-ext-multiselect.git application/extensions/preside-ext-multiselect ``` https://forgebox.io/view/preside-ext-multiselect Tue, 22 Jul 2025 04:03:17 GMT preside-extensions https://forgebox.io/view/preside-ext-multiselect # Preside Data API Extension The Data API extension provides developers with the power to rapidly develop APIs against their Preside data models. With a few simple object annotations and optional i18n resource keys, developers are able to provide full CRUD APIs to the data model with beautifully rendered API documentation. **Note**: Version **3.0.0** requires Preside version **10.11.0** and above. ## Accessing the API The **default** root URI of the API is `/api/data/v1/` (see _Namespaces and multiple APIs_, further below). OpenAPI v3 specification can be browsed at `/api/data/v1/docs/spec/` and HTML documentation based on the spec can be found at `/api/data/v1/docs/html/` (or `/api/data/v1/docs/swagger/`, if you prefer). ## Configuring your entities ### Object annotations The _bare minimum_ configuration to enable an object for the API is to set `@dataApiEnabled true`: ``` /** * @dataApiEnabled true * */ component { // ... } ``` Additional _optional_ annotation options at the _object_ level are: * `dataApiEntityName`: Alternative entity name to use in API urls, e.g. instead of `crm_contact`, you may wish to use `contact`. * `dataApiCategory`: For the HTML documentation. Allows sub-groups of entities. Especially useful for large APIs. * `dataApiQueueEnabled`: Whether or not the change queue is enabled for this object * `dataApiQueue`: Specific queue name for this object * `dataApiSortOrder`: Sort order for paginated results. Default is date last modified ascending. * `dataApiSavedFilters`: Comma-separated list of saved filters to apply to all requests to this object (e.g. only return active records) * `dataApiVerbs`: Supported REST HTTP Verbs. If not supplied, all verbs and operations are supported (i.e. GET, POST, PUT and DELETE) * `dataApiFields`: Fields to return in GET requests (defaults to all non-excluded fields) * `dataApiUpsertFields`: Fields to accept in POST/PUT request (defaults to `dataApiFields`) * `dataApiExcludeFields`: Fields to exclude from GET API calls * `dataApiUpsertExcludeFields`: Fields **not** to accept in POST/PUT requests (defaults to `dataApiExcludeFields`) * `dataApiFilterFields`: Fields to allow as simple filters for paginated GET requests (defaults to foreign keys, boolean and enum fields) * `dataApiAllowIdInsert`: Whether or not to allow the ID field to be set during a POST operation to create a new record ### Property annotations Object properties support the following _optional_ annotations: * `dataApiAlias`: An alternative name to use for the property in the API. i.e. instead of `contact_status` you may wish to just use `status` through the API. * `dataApiRenderer`: A non-default renderer to use when returning data through the API. See custom renderers, below. * `dataApiDerivative`: For image assets, specify the derivative to be used when rendering URLs. * `dataApiType`: For the documentation. The data type of the property, e.g. 'string'. * `dataApiFormat`: For the documentation. The format for the property, e.g. 'Email address'. * `dataApiEnabled`: Whether or not this property should be included in the API * `dataApiUpsertEnabled`: Whether or not this property should be included in the POST/PUT operations. ## Custom renderers If you specify a non-default renderer for an object property, it will be rendered using Preside's content rendering system. For example, the following property definition specifies a `myCustomRenderer` renderer: ``` property name="my_prop" dataApiAlias="myProp" dataApiRenderer="myCustomRenderer"; ``` To implement this, you will need a corresponding _viewlet_ at `renderers.content.myCustomRenderer.dataapi` **or** `renderers.content.myCustomRenderer.default` (a renderer _context_ of `dataapi` will be used and the system will fallback to the default renderer if that context is not implemented). For example: ``` // /handlers/renderers/content/MyCustomRenderer.cfc component { private string function dataApi( event, rc, prc, args={} ){ var value = args.data ?: ""; return renderView( view="/renderers/content/myCustomRenderer/dataApi", args={ value=value } ); } } ``` ## Customizing documentation labels and descriptions All of the labelling and text in the generated documentation can be found at `/i18n/dataapi.properties` and you should refer to that when customizing the default text. A bare minimum override might look like: ``` api.title=My Application's API api.description=This is my awesome application's API and here is some general information about it.\n\ \n\ Team awesome xxx. api.version=v2.0 api.favicon=data:image/x-icon;base64,iVBOR... ``` ### Categories If you annotate your objects with a `@dataApiCategory` property, your categories can be documented with: ``` category.my_category.name=My Category category.my_category.description=Markdown enabled description of my category. category.my_category.sort.order=20 ``` ### Object and field level customizations The following set of `.properties` file keys can be added _per_ object in your own `dataapi.properties` files to customize the documentation per entity/field: ``` # OBJECT LEVEL: dataapi:entity.my_entity.name=My entities dataapi:entity.my_entity.name.singular=My entity dataapi:entity.my_entity.description=Description of my entity (or API description for this section of the docs) dataapi:entity.my_entity.sort.order=10 dataapi:operation.my_entity.get.description=Description for the paginated GET operation for your entity dataapi:operation.my_entity.get.200.description=Description for the successful (200) response documentation for paginated GET requests for your entity dataapi:operation.my_entity.get.by.id.description=Description for the GET /{recordId}/ operation for your entity dataapi:operation.my_entity.get.by.id.200.description=Description for the successful (200) response documentation for GET /{recordId}/ requests for your entity dataapi:operation.my_entity.get.by.id.404.description=Description for the not found (404) response documentation for GET /{recordId}/ requests for your entity dataapi:operation.my_entity.put.description=Description for the PUT / (batch update) operation for your entity dataapi:operation.my_entity.put.body.description=Description for the http json body for the PUT / (batch update) operation for your entity dataapi:operation.my_entity.put.200.description=Description for the successful (200) response documentation for PUT / requests for your entity dataapi:operation.my_entity.put.422.description=Description for the validation failed (422) response documentation for PUT / requests for your entity dataapi:operation.my_entity.put.by.id.description=Description for the PUT /{recordid}/ (single record update) operation for your entity dataapi:operation.my_entity.put.by.id.body.description=Description for the http json body for the PUT /{recordid}/ (single record update) operation for your entity dataapi:operation.my_entity.put.by.id.200.description=Description for the successful (200) response documentation for PUT /{recordid}/ requests for your entity dataapi:operation.my_entity.put.by.id.422.description=Description for the validation failed (422) response documentation for PUT /{recordid}/ requests for your entity dataapi:operation.my_entity.put.by.id.404.description=Description for the record not found (404) response documentation for PUT /{recordid}/ requests for your entity dataapi:operation.my_entity.post.description=Description of the POST / (batch insert) operation for your entity dataapi:operation.my_entity.post.body.description=Description for the http json body for the POST / (batch insert) operation for your entity dataapi:operation.my_entity.post.200.description=Description for the successful (200) response documentation for POST / requests for your entity dataapi:operation.my_entity.post.422.description=Description for the validation failed (422) response documentation for POST / requests for your entity dataapi:operation.my_entity.delete.description=Description of the DELETE /{recordid}/ operation for your entity dataapi:operation.my_entity.delete.200.description=Description of the successful (200) response documentation for DELETE /{recordId}/ operations for your entity # Field level dataapi:operation.my_entity.get.params.fields.my_field.description=Description for *filter* field dataapi:entity.my_entity.field.my_field.description=Description of field ``` ## Further customizations using interceptors The following interception points are used to allow you to more deeply customize the integration. ### `onOpenApiSpecGeneration` Fired when generating OpenApi v3 specification for the API. A `spec` struct will be present in the `interceptorArgs` that you can use to augment the specification. ### `preDataApiSelectData` Fired before selecting data through the API. Receives the following keys in the `interceptData`: * `selectDataArgs`: Arguments that will be passed to the `selectData()` call * `entity`: Name of the entity being operated on ### `postDataApiSelectData` Fired after selecting data through the API. Receives the following keys in the `interceptData`: * `selectDataArgs`: Arguments that were passed to the `selectData()` call * `entity`: Name of the entity being operated on * `data`: Rendered and prepared data that will be returned to the API caller ### `preDataApiInsertData` Fires before inserting data through the API. Receives the following keys in the `interceptData`: * `insertDataArgs`: Arguments that will be passed to the `insertData()` call * `entity`: Name of the entity being operated on * `record`: The data that will be inserted (struct) ### `postDataApiInsertData` Fires after inserting data through the API. Receives the following keys in the `interceptData`: * `insertDataArgs`: Arguments that were passed to the `insertData()` call * `entity`: Name of the entity being operated on * `record`: The data that will be inserted (struct) * `newId`: Newly created record ID ### `preDataApiUpdateData` Fires before updating data through the API. Receives the following keys in the `interceptData`: * `updateDataArgs`: Arguments that will be passed to the `updateData()` call * `entity`: Name of the entity being operated on * `recordId`: ID of the record to be updated * `data`: The data that will be inserted (struct) ### `postDataApiUpdateData` Fires after updating data through the API. Receives the following keys in the `interceptData`: * `updateDataArgs`: Arguments that were passed to the `updateData()` call * `entity`: Name of the entity being operated on * `recordId`: ID of the record to be updated * `data`: The data that will be inserted (struct) ### `preDataApiDeleteData` Fires before deleting data through the API. Receives the following keys in the `interceptData`: * `deleteDataArgs`: Arguments that will be passed to the `deleteData()` call * `entity`: Name of the entity being operated on * `recordId`: ID of the record to be deleted ### `postDataApiDeleteData` Fires after deleting data through the API. Receives the following keys in the `interceptData`: * `deleteDataArgs`: Arguments that were passed to the `deleteData()` call * `entity`: Name of the entity being operated on * `recordId`: ID of the record to be deleted ## Data Change Queue(s) By default, they system enables a queue feature: `settings.features.dataApiQueue`. When enabled, API users can be subscribed, through the admin UI, to listen for data changes to all, or a number, of entities in the system. ### Configuring the queue system As of **v3.0.0**, you have the ability to configure multiple queue endpoints per API (see also, _Namespaces and multiple APIs_, below). This can be used to group entities into queues so that multiple different services can process the queues independently. The available settings per queue are: * `pageSize`: Number of records returned with each call to queue. Default is **1** * `atomicChanges`: Whether or not the queue should return atomic changes. If true, each item in the queue will contain only the fields that have changed. If false, default, each item in the queue will contain the latest state of the record. Default is **false**. * `returnTotalRecords`: Whether or not to return X-Total-Records header with the total queue size when getting items from the queue (default is `true`) #### Defining queues Queues are defined in the Preside rest API configuration in `Config.cfc`. To add a queue definition to the default API: ```cfc settings.rest.apis[ "/data/v1" ].dataApiQueueEnabled = true; settings.rest.apis[ "/data/v1" ].dataApiQueues = { default = { pageSize=100, atomicChanges=true } // the default queue , highvolume = { pageSize=1000, atomicChanges=false, returnTotalRecords=false } }; ``` #### Per object queue settings: Annotate your preside object CFC with `@dataApiQueueEnabled` (default is **true**) and `@dataApiQueue` (default is **default**) properties. For example: ```cfc /** * @dataApiQueueEnabled false */ ``` or ```cfc /** * @dataApiQueue highvolume */ ``` #### Skip a data api queue: To prevent data api queue to be created when you insert data into an object, you can set `skipDataApiQueue = true` as argument in the `insertData` function. For example: ``` $getPresideObject( "example_object" ).insertData( data = { example_field_name = "example_value" } , skipDataApiQueue = true ); ``` ## Namespaces and multiple APIs *Introduced in v2.0.0* By default, the API is exposed at `/api/data/v1/`. However, there will be occasions when you want to expose your data in different ways for different purposes. Or, if you are writing an extension, you may want to namespace your API so that it does not clash with any existing default API implementation. You can also use this feature to host multiple versions of your API concurrently. With just a small amount of configuration, you can use all of the Data API's functionality in a separate, namespaced instance. First, configure the endpoints in your `Config.cfc`: ``` settings.rest.apis[ "/myGroovyApi/v1" ] = { authProvider = "dataApi" , description = "REST API to expose data with an alternate structure" , dataApiNamespace = "myGroovyApi" , dataApiQueueEnabled = true , dataApiQueues = { default = { pageSize=100, atomicChanges=true } } }; settings.rest.apis[ "/myGroovyApi/v1/docs" ] = { description = "Documentation for myGroovyApi REST API (no authentication required)" , dataApiNamespace = "myGroovyApi" , dataApiDocs = true }; ``` A few things to note here: * The key within `settings.rest.apis` (e.g. `/myGroovyApi/v1`) is the base URI for the API. This will have `/api` prepended to it in the full URL. * `dataApiNamespace` is the namespace for the alternate API, and will be used when configuring objects. This will usually be the first part of the URI, but does not need to be. * `dataApiDocs` marks that this is the endpoint for the Swagger documentation. This whole endpoint could be omitted if you do not require the automatic document generation. * Use `authProvider` to mark an endpoint as needing authentication. If you omit this, the resource will not require authentication. In the API Manager in Preside, you can allow users to have access to individual APIs - so a user could have access to `/api/myGroovyApi/v1` but not to the default `/api/data/v1`, if you wish. ### Annotations You can annotate your objects using exactly the same annotations as described above, but with `:{namespace}` appended. For example: ``` /** * @dataApiEnabled true * @dataApiEnabled:myGroovyApi true * @dataApiVerbs:myGroovyApi GET * */ component { property name="label" dataApiAlias:myGroovyApi="some_other_label"; } ``` This would enable this object both for the default `/data/v1` API, and for your custom `/myGroovyApi/v1` API. However, for `myGroovyApi` the object would only allow `GET` access, and the label field would be called `some_other_label` instead of `label`. You could also use this to specify an alternate renderer for a property, e.g. `dataApiRenderer:myGroovyApi="alternateRenderer"`. Note that namespaces do not inherit any annotations from the default API. Any annotations must be made explicitly with the `:{namespace}` suffix. ### Labelling and text You can use all the same label and description customisations in your `/i18n/dataapi.properties` file as above; simply prefix the key name with `{namespace}.`. For example: ``` myGroovyApi.api.title=My Second API myGroovyApi.api.description=This is an alternate API to my application myGroovyApi.entity.my_entity.name=My alternate entity ``` Unlike annotations, i18n properties _will_ cascade up to the defaults. So if you do not make any customisations, you will see all the default text. ### Interceptors All the same interceptors will run when actions are taken in a namespaced API. However, the interception point name will have `_{namespace}` as a suffix. Again, there is no fallback to the default interceptor, so any interceptors will need to be explicitly defined for your namespace. For example: ``` public void function preDataApiSelectData( event, interceptData ) { // action to take for preDataApiSelectData on the default API } public void function preDataApiSelectData_myGroovyApi( event, interceptData ) { // action to take for preDataApiSelectData on the myGroovyApi API } ``` ## Configuring individual user access Provided that your APIs use the 'dataApi' auth provider (default), you will be able to manage user access to the APIs through the admin interface. 1. Navigate to: **System** > **API Manager** 2. Find the API you want to manage & click 'Data API authentication' 3. Click Add user 4. Enter a user name (can lookup existing users also) and configure access to individual entities, their verbs and optionally queue access https://forgebox.io/view/preside-ext-data-api Mon, 16 Mar 2026 09:12:16 GMT preside-extensions https://forgebox.io/view/preside-ext-data-api https://forgebox.io/view/ext-preside-swiper-slider Tue, 03 Mar 2026 09:00:24 GMT preside-extensions https://forgebox.io/view/ext-preside-swiper-slider # Preside Validation Extras A collection of useful additional validators for use with Preside's forms system. ## Installation ```box install preside-ext-validation-extras``` ## The validators ### requiredIfOtherFieldChecked Makes a field required if another specified checkbox field is checked. ```xml ``` ### requiredIfOtherFieldNotChecked Makes a field required if another specified checkbox field is not checked. ```xml ``` ### requiredIfOtherFieldEmpty Makes a field required if another specified field is empty. In this example, at least one of the inputs would have to be filled. ```xml ``` ### requiredIfOtherFieldNotEmpty Makes a field required if another specified field is not empty. In this example, if one input is filled then the other is also required. ```xml ``` ### requiredIfOtherFieldValue Makes a field required if the value of another field matches the specified value. Here, if "Yes" is chosen from the subcribe select control, then the email address is required. ```xml ``` ### simpleUrl Checks for a simple web URL. Requires either `http://` or `https://` at the start. ```xml ``` ### ukPhone Validates a phone number is valid for the UK. Allows brackets, spaces, `+44` or `0` prefix, and an optional extension following a #. ```xml ``` ### ukPostcode Validates a UK postcode format. Valid with or without a space in the middle. ```xml ``` ### ukDrivingLicence Validates a UK driving licence number. ```xml ``` # Contributing Contribution in all forms is very welcome. Use Github to create pull requests for tests, logic, features and documentation. Or, get in touch over at Preside's slack team and we'll be happy to help and chat: [https://presidecms-slack.herokuapp.com/](https://presidecms-slack.herokuapp.com/). https://forgebox.io/view/preside-ext-validation-extras Tue, 24 Feb 2026 13:29:13 GMT preside-extensions https://forgebox.io/view/preside-ext-validation-extras # ElasticSearch extension for Preside This is an extension for the Preside Platform that provides APIs and a methodolgy for integrating full-text search with ElasticSearch. ## Installation From the webroot of your application: ``` box install preside-ext-elasticsearch ``` ## Documentation Documentation is a work in progress. For now, we intend to use the [Github Wiki](https://github.com/pixl8/preside-ext-elasticsearch/wiki) and could do with all the help we can get. Contributions very welcome! ## Versioning We use [SemVer](https://semver.org) for versioning. As of **6.3**, we aim to keep versioning inline with the minimum ElasticSearch engine version that the extension supports. For the versions available, see the [tags on this repository](https://github.com/pixl8/preside-ext-elasticsearch/releases). Project releases can also be found and installed from [Forgebox](https://forgebox.io/view/preside-ext-elasticsearch) ## License This project is licensed under the GPLv2 License - see the [LICENSE.txt](https://github.com/pixl8/Preside-CMS/blob/master/LICENSE.txt) file for details. ## Authors The project is maintained by [The Pixl8 Group](https://www.pixl8.co.uk). The lead developer is [Dominic Watson](https://github.com/DominicWatson). ## Code of conduct We are a small, friendly and professional community. For the eradication of doubt, we publish a simple [code of conduct](https://github.com/pixl8/preside-ext-elasticsearch/blob/master/CODE_OF_CONDUCT.md) and expect all contributors, users and passers-by to observe it. https://forgebox.io/view/preside-ext-elasticsearch Fri, 24 Jan 2025 11:58:03 GMT preside-extensions https://forgebox.io/view/preside-ext-elasticsearch The Alternate Admin Theme extension provides a refresh to the original Preside core admin layout and styling, and also adds customisation options. https://forgebox.io/view/preside-ext-alt-admin-theme Tue, 27 Jan 2026 15:02:32 GMT preside-extensions https://forgebox.io/view/preside-ext-alt-admin-theme # Socket.IO For Preside Supply a helpful README here. https://forgebox.io/view/preside-ext-socket-io Fri, 16 Jan 2026 14:43:29 GMT preside-extensions https://forgebox.io/view/preside-ext-socket-io An extension for Preside that will create an XML Sitemap for all active pages https://forgebox.io/view/preside-ext-sitemap Wed, 10 Dec 2025 08:58:51 GMT preside-extensions https://forgebox.io/view/preside-ext-sitemap # Preside Content Library Extension This extension provides your Preside applications with a content library that can be used to create pieces of content that can be shared in multiple places. In addition, each content item can have a set of conditional alternatives; for example: show some alternative content when user is already booked on Event X. ## Requirements This extension requires **Preside 10.9.0** or higher. ## Installation Install with Commandbox: ``` box install preside-ext-content-library ``` ## Usage ### Creating content On installation, you should see a "Content library" menu item in the admin beneath the site tree menu item. From here, users can add pieces of content, including configuring conditional alternatives. ### Including content From any richeditor with Preside widgets available, insert the "Content library" widget and choose the piece of content you wish to insert. https://forgebox.io/view/preside-ext-content-library Wed, 29 Oct 2025 07:55:01 GMT preside-extensions https://forgebox.io/view/preside-ext-content-library # Chart.js for Preside https://forgebox.io/view/preside-ext-chart-js Wed, 29 Oct 2025 01:51:10 GMT preside-extensions https://forgebox.io/view/preside-ext-chart-js # preside-ext-turnstile A Preside Extension to override Preside's default reCaptcha support with Cloudflare's Turnstile https://developers.cloudflare.com/turnstile/ https://forgebox.io/view/preside-ext-turnstile Wed, 22 Oct 2025 02:38:11 GMT preside-extensions https://forgebox.io/view/preside-ext-turnstile # Google Tag Manager for Preside This extension is for installing configuration for adding Google Tag Manager (GTM) scripts to the HEAD and BODY sections of the required layout templates as per the instructions in GTM. ## Installation From a commandline at the root of your application: ``` box install preside-ext-google-tag-manager ``` ## Configuration Once installed, login to the Preside admin and head to **System -> Settings -> Google Tag Manager** and enter the snippets from the instructions section in Google Tag Manager **Admin -> Container -> install Google Tag Manager** . ## Usage The extension will take care of inserting the Google Tag manager "snippets" into your layout automatically for you, you won't need to do anything else. However, you can customize the layouts that are effected. To customize the layouts, set the `settings.googleTagManager.layouts` variable in your `Config.cfc`: ``` settings.googleTagManager.layouts = [ "main", "newsletter" ]; // default is [ "main" ] ``` ### Note If you're using the Google Analytics extension, please ensure this is removed or the configuration for the tracking ID is removed to help prevent double tags/events being fired. ## Contributing and roadmap Pull requests, issues and ideas are all welcome :) Please get in touch with the Preside team on our [Preside Slack](https://presidecms-slack.herokuapp.com/). https://forgebox.io/view/preside-ext-google-tag-manager Wed, 22 Oct 2025 02:36:07 GMT preside-extensions https://forgebox.io/view/preside-ext-google-tag-manager # Preside admin Launcher The Preside admin launcher extension brings "quick find/launch" functionality to the Preside admin. ## Installation ``` box install preside-ext-launcher ``` ## Configuration The launcher will work as is out of the box if you have a standard Preside admin layout. However, there are some configuration options that you should be aware of to help you tweak the functionality to your requirements. In Config.cfc ```cfc // default datasources list: // tweak this to add your own datasources // and/or change the priority order of datasources settings.launcher.datasources = [ "thispage", "recent", "pages", "objectdata", "navigation"]; // default objects for the objectData + recentObjectData datasources // you should configure this array with key objects that // should be quick findable in your application. settings.launcher.objectDatasources = [ "crm_contact", "crm_organisation" ]; // empty by default // whether or not to auto inject the launcher // into the admin layout header. If you are not // using the default admin layout, you may need to set this // to false and render the launcher yourself in your header settings.launcher.autoInjectInHeader = true; // maximum number of items to store in the recently // visited records datasource (stores in the database) settings.launcher.maxRecentlyVisitedItems = 20; ``` ## Custom datasources You can add your own custom datasources by adding them to the `settings.launcher.datasources` array. e.g. ```settings.launcher.datasources.append( "mycustomdatasource" )``` Each datasource must then implement: ### i18n entry Two entries in `/i18n/launcher.properties`, one for the title and one for the iconClass. e.g. ```properties datasource.mycustomdatasource.title=My datasource datasource.mycustomdatasource.iconClass=fa-database purple ``` ### Config handler Create a handler with a `config` method at `/handlers/admin/launcher/datasource/{datasourcename}.cfc`. The `config` method should return a configuration struct for the datasource (see reference below). You may also optionally implement `recordRecentlyVisited()` and `renderRecentlyVisitedItem()` actions to allow visits to pages in your datasource to appear in the 'Recently visited' menu. For example: ```cfc component { property name="launcherService" inject="launcherService"; private array function config( event, rc, prc ) { return launcherService.getObjectDataDatasources(); } /** * Runs at the end of a request and should return a * struct of data to identify the recently visited page * (empty struct if current page not relevent to your datasource) * Logic to determine this is up to you. Receives no arguments. */ private struct function recordRecentlyVisited( event, rc, prc ) { if ( Len( Trim( prc.objectName ?: "" ) ) && Len( Trim( prc.recordId ?: "" ) ) ) { return { objectName = prc.objectName , recordId = prc.recordId } } return {}; } /** * Must return a launcher item struct representing the saved * recently visited item. Receives the data you returned in * recordRecentlyVisited() as arguments. * Return {} to have the item ignored. */ private struct function renderRecentlyVisitedItem( event, rc, prc, objectName="", recordId="" ) { if ( Len( Trim( arguments.recordId ) ) && Len( Trim( arguments.objectName ) ) ) { return { id = "recent-" & arguments.recordId , icon = translateResource( uri="preside-objects.#arguments.objectName#:iconClass", defaultValue="fa-database" ) , text = renderLabel( arguments.objectName, arguments.recordId ) , description = "" , url = event.buildAdminLink( objectName=arguments.objectName, recordId=arguments.recordId ) }; } return {}; } } ``` ### Datasource config reference Each datasource config is defined as a struct with the following keys: * `local` (optional, required if no `remoteURL`): an array of items (see item reference below) for the launcher * `defaultSuggestions` (optional): an array of items that will be shown as soon as the launcher is focused * `remoteUrl` (optional, required if no `local`): URL that will return a json array of items given a search query. Should contain a `%QUERY` token that will be replaced with the currently active search term * `prefetchUrl` (optional): URL that will return a json array of items to prepopulate search for the datasource * `javascriptSrc` (optional): `boolean`. If `true`, then a javascript event will be triggered on the `$( "#preside-launcher-input" )` input matching the datasource name that allows you to configure the datasource in javascript. See javascript datasource below ### Item reference Each item in a datasource is represented as a struct with the following items: * `id`: unique ID of the item * `text`: searchable and displayed text * `description`: optional description of the item * `icon`: font-awesome icon class to display with the item * `url`: URL to browse to when item is selected ### Javascript datasources Javascript based datasources can be created by setting a `javascriptSrc=true` configuration in your datasource config handler and providing javascript that listens for the jQuery event `prepare{lower-cased-datasource-name}Datasource`. The event will be passed three arguments: 1. the javascript event object 2. an empty 'helper' object. You are expected to set a 'bh' key in here with a configured BloodHound instance 3. a 'config' object containing the launcher datasource from Preside Example: ```js ( function( $ ){ ( "#preside-launcher-input" ).on( "preparethispageDatasource", function( ev, helper, config ){ var items = [{text:"Oranges", ...}, {text:"Apples", ...}]; // should have same keys as item definition, above helper.bh = new Bloodhound( $.extend( {}, { datumTokenizer : function(d) { return Bloodhound.tokenizers.whitespace( d.text); } , queryTokenizer: Bloodhound.tokenizers.whitespace , local : items }, config.bloodhoundOptions ) ); config.typeaheadOptions.minLength = 0; config.typeaheadOptions.source = function(q, sync) { if ( q === '' ) { sync( items ); } else { helper.bh.ttAdapter()(q, sync); } } } ); } ); ``` ### ObjectData datasource The ObjectData datasource allows you to search preside objects (configured in `settings.launcher.objectDatasources`) within your application. By default, the launcher will search the `labelfield` of the given object. If you want a specific set of fields to be used for searching you can add a `launcherSearchFields` attribute to your object cfc. ```cfc /** * @launcherSearchFields productId,label */ component { property name="productId" ype="string" dbtype="varchar" maxlength=40 uniqueIndexes="product_identifers"; // .. etc. } ``` https://forgebox.io/view/preside-ext-launcher Tue, 21 Oct 2025 14:59:56 GMT preside-extensions https://forgebox.io/view/preside-ext-launcher # Timezone definitions This extension provides data on timezones and VTIMEZONE definitions for use in iCal/vCal files. https://forgebox.io/view/preside-ext-timezones Tue, 21 Oct 2025 03:04:21 GMT preside-extensions https://forgebox.io/view/preside-ext-timezones # Preside Content Dependency Tracker This is an extension for [Preside](https://www.preside.org) that provides tracking of content objects and their dependencies. Content objects could be pages, assets, links, rules engine conditions, system settings, helper objects. etc. The extension comes with a set of already configured content objects for tracking from the Preside Core. It's up to you to configure it in a way that fits your site or application. As of now this extension is considered **alpha** and therefore to be used with caution. It has not been tested extensively with large databases yet. In detail the extension provides the following functionality: * admin interface to track configured content objects including their dependencies (bi-directional) * automatic tracking tasks (full scanning/indexing and also index on changes) * deal with both hard references (database foreign keys) and also soft references (e.g. objects used in rich editor content) * Possibility to identifiy orphans and broken dependencies * link in and out from/to Preside System (e.g. from an asset in asset manager see number of dependencies and directly link into the tracker) ATTENTION: as of now this extension depends on the better-view-record-screen extension which is not open sourced (yet), stay tuned, as it will be soon... ## Installation From the root of your application, type the following command in a terminal: ``` box install preside-ext-content-dependency-tracker --saveDev ``` ## Configuration All settings for this extension are located in the `Config.cfc` as in the following way: ``` settings.contentDependencyTracker = { autoEnableDbTextFields = false , trackObjects = { asset = { enabled=true } ... , page = { enabled = true , properties = { main_content = { enabled=true } , parent_page = { enabled=false } , site = { enabled=false } } } , system_config = { enabled = true , hideIrrelevantRecords = true , labelGenerator = "dependencyTrackerSystemConfigLabelGenerator" , labelRenderer = "dependencyTrackerSystemConfigLabelRenderer" , viewRecordLinkRenderer = "dependencyTrackerSystemConfigLinkRenderer" , properties = { value = { enabled=true } , site = { enabled=false } } } } , linkToTrackerEvents = { "admin.datamanager.viewRecord" = { contentTypeParam="object" , contentIdParam="id" } , "admin.datamanager.editRecord" = { contentTypeParam="object" , contentIdParam="id" } , "admin.assetmanager.editAsset" = { contentType="asset" , contentIdParam="asset" } , "admin.sites.editSite" = { contentType="site" , contentIdParam="id" } , "admin.sitetree.editPage" = { contentType="page" , contentIdParam="id" } , "admin.emailcenter.systemTemplates.template" = { contentType="email_template", contentIdParam="template" } ... } }; ``` `autoEnableDbTextFields` will automatically enable all `dbtype="text"` fields on all objects that are enabled for tracking. `trackObjects.{any_preside_object}.enabled` will enable (or disable) an object for tracking. Enabling/disabling properties is done like this: `trackObjects.{preside_object_name}.properties.{property_name}.enabled` Foreign Key properties (`many-to-one` and `many-to-many` relationships) will be automatically enabled if this is configured in the System Settings (see below). If you explicitly want to disable a specific FK from being indexed, then disable it here in the `Config.cfc`. For example the default configuration disables the parent_page and site properties, see above. Non-relationsship fields always need to be manually enabled, e.g. have a look at the `value` property from the `system_config` object in the default configuration above. `hideIrrelevantRecords=true` will mark indexed content records as `hidden`, if no single dependency exists. You can control to not show hidden records via System settings (see further down below). `labelGenerator` can be used on object-level in order to have a custom content renderer to be used when generating the label of the Content object. `labelRenderer` is defined on object-level to have a custom content renderer be used to render the label of the content object. For example the extension uses these two in combination to generate and render labels for the `system_config` object. In that case the generator uses `{category}:{setting}` for sys-config objects and the renderer uses i18n translations for those to make it render pretty (and language-aware), e.g. you could then have a `system_config` Content Object with the label `website_users:default_post_login_page` which automatically renders to `Website user config: Default post login page`. `viewRecordLinkRenderer` is used to define a custom content renderer to use for generating the link from the Dependency Tracker UI to the actual preside object record view. By default and if nothing custom is specified the system will just use a general datamanager view record link. This might not work for some special records, e.g. in the default implementation `system_config` as well as `email_template` records need special links. See actual code of this extension how this is solved. In order to be able to link from individual object records into the dependency tracker (and see the dependencies), the system need to know which events should be supported. This is done by the configuration beneath `linkToTrackerEvents`. It is a struct which has the actual Coldbox event names as the key, e.g. `admin.datamanager.viewRecord` is the standard datamanager view record event. The configuration for each event needs to have a `contentIdParam` - this is the Request Context (`rc`) param where the logic should detect the ID of the record. To determine the content type of the record (e.g. whether it's an asset, a page, an email_template, etc.) can be done in 2 ways. Either it's specified in a fix way using the `contentType` param, or use `contentTypeParam` to have the system check for the object type in the defined `rc` param. All these settings can be tweaked/overwritten within your site's own `Config.cfc`. For example if you want a custom object to be added, you would do something like this: ``` settings.contentDependencyTracker = settings.contentDependencyTracker ?: {}; settings.contentDependencyTracker.trackObjects = settings.contentDependencyTracker.trackObjects ?: {}; settings.contentDependencyTracker.trackObjects.my_custom_object = { enabled=true, properties={ some_field={ enabled=true } } } ``` Note: In order to track dependencies between content objects you need to make sure that both sides of the dependency are enabled for tracking. ### Annotations All settings underneath `settings.contentDependencyTracker.trackObjects` can also be configured directly on your Preside objects via annotations. The annotations are labelled exactly the same, with the exception that a `dependencyTracker` prefix is needed. For example the following is the `email_template.cfc` from the extension: ``` /** * @dependencyTrackerEnabled true * @dependencyTrackerViewRecordLinkRenderer dependencyTrackerEmailTemplateLinkRenderer */ component { property name="html_body" dependencyTrackerEnabled=true; } ``` This will enable dependency tracking for `email_template` objects and specifically check the `html_body` property for soft references to other defined content objects. ### Configuring your own objects for tracking You can configure content objects for tracking in 2 ways, either by adding them in the settings of your application's `Config.cfc` or via Preside object annotations. Annotations take precedence over `Config.cfc`. It's totally up to you which method you want to use. If you want to track content objects from other extensions within your application, the `Config.cfc` settings are a bit handier than annotations as you do not need to create a copy of all the Preside Objects from those extensions within your application. In addition, if there are objects defined to be tracked in the settings in `Config.cfc` and these do not exist at all in the current application, they are simply ignored without an error. ## Usage After configuration, the actual usage of the extension can be divided in 2 parts: * automatic finding and indexing of tasks * making use of the indexed data ### Tasks Two scheduled tasks exist to scan and index your objects for dependencies. Go to `System > Task Manager` and check the `Content` tab there. You will find: * `[1] Scan all content object dependencies` * `[2] Scan changed content object for dependencies` The first one will perform a full re-index of all objects. Depending on the amount of records to be scanned, that might take a while. You could either only manually execute this or run it infrequently, e.g. nightly. The second one should be run frequently, e.g. by default it is configured to run every 5 minutes. This only scans objects that require scanning. This only works if single record indexing is enabled. See below. ### System Settings There are a couple of switches you can turn on/off in the system settings, which you find in the Preside admin here: `System > Settings > Content Dependency Tracker`. * `Enabled`: global switch to enable/disable the whole content tracking * `Foreign Key Scanning`: whether FK scanning should take place or not * `Soft Reference Scanning`: whether non-relationship fields should be scanned * `Hide all irrelevant records`: Flag all records without dependencies as hidden (you can also have this disabled here but enable it on a per-object basis using annotations) * `Show hidden records`: whether content records flagged as `hidden` should be shown in the Dependency Tracker listing or not. * `Show all orphaned records`: On deletion content records are flagged as `orphaned`. This setting controls if those should be displayed in the Dependency Tracker listing or not. * `Single Record Scanning`: Will enable content objects to be flagged as `requires_scanning` on insert/update/delete. If both FK + Soft Ref Scanning is disabled, the whole system is basically disabled. Recommended settings to make the most out of the extension: Disable `Hide all irrelevant records` and `Show hidden records`, enable all others. ### Dependency Tracker Listing Find the listing of Content objects and there dependencies in the Preside Admin underneath `System > Dependency Tracker`. Recommendations: Make yourself 1-click fav filters for the following two cases: * `orphaned` > filter for `orphaned=true` * `broken dependencies` > filter for `has more than 0 Uses matching optional filter broken`, where `broken` is a sub filter which is defined as `Dependent Content Object matches the following Dependency Tracker filter: orphaned` ### Clean-Up Orphans There is a button in the Dependency Tracker Listing at the top right corner to remove all orphans which do not have any dependencies. You can manually execute it from time to time to get rid of obsolete data. Orphans which have dependencies will not be removed. E.g. you might have a rules engine filter used within a conditional content widget within a page - and that rules engine filter got deleted but is still in use in that page. Then the content object for this record will not be deleted. ### Link into Tracker UI from Core System There is a feature that allows a global link to be rendered for configured content objects from anywhere in the Preside Admin into the Content Tracker. It is disabled by default but you can enable it in your `Config.cfc` as follows: ``` settings.features.globalLinkToDependencyTracker.enabled = true; ``` This will render a link whenever possible in the global navigation of the Preside Admin when viewing an object that is tracked. The link will show the number of dependencies and direct you to the content tracker. So for example if enabled you can see in the asset manager for an individual asset whether it's used and if so how often. Details of the dependencies can then be seen when clicking the link and being directed to the content object within the Dependency Tracker UI. ## Versioning We use [SemVer](https://semver.org) for versioning. For the versions available, see the [tags on this repository](https://github.com/pixl8/preside-ext-content-dependency-tracker/releases). Project releases can also be found and installed from [Forgebox](https://forgebox.io/view/preside-ext-content-dependency-tracker). ## License This project is licensed under the GPLv2 License - see the [LICENSE.txt](https://github.com/pixl8/preside-ext-content-dependency-tracker/blob/stable/LICENSE.txt) file for details. ## Changes / Contributions Find all changes in the [CHANGELOG.md](https://github.com/pixl8/preside-ext-content-dependency-tracker/blob/stable/CHANGELOG.md) Feel free to fork and pull request to contribute. Any additional feedback is very welcome - preferable via Github issues or on the Preside Slack channel. https://forgebox.io/view/preside-ext-content-dependency-tracker Fri, 17 Oct 2025 04:00:19 GMT preside-extensions https://forgebox.io/view/preside-ext-content-dependency-tracker # Google Analytics for Preside This extension allows you to easily insert Google Analytics "tags" into your Preside website's pages. ## Installation From a commandline at the root of your application: ``` box install preside-ext-google-analytics ``` ## Configuration Once installed, login to the Preside admin and head to **System -> Settings -> Google Analytics** and enter your analytics credentials. ## Usage The extension will take care of inserting analytics "tags" into your layout automatically for you, you won't need to do anything else. However, you can customize the layouts that are effected and the script itself. To customize the layouts, set the `settings.googleAnalytics.layouts` variable in your `Config.cfc`: ``` settings.googleAnalytics.layouts = [ "main", "newsletter" ]; // default is [ "main" ] ``` To customize the output of the analytics script, implement your own view at `/views/general/_googleAnalyticsTags.cfm`, the view will be passed two `args`: `gaId` and `layout`. For example: ``` // /views/general/_googleAnalyticsTags.cfm (function(i,s,o,g,r,a,m){i['GoogleAnalyticsObject']=r;i[r]=i[r]||function(){ (i[r].q=i[r].q||[]).push(arguments)},i[r].l=1*new Date();a=s.createElement(o), m=s.getElementsByTagName(o)[0];a.async=1;a.src=g;m.parentNode.insertBefore(a,m) })(window,document,'script','//www.google-analytics.com/analytics.js','ga'); ga('create', '#args.gaId#', 'auto'); ga('send', 'pageview'); some special example for newlsetters here ``` ## Contributing and roadmap Pull requests, issues and ideas are all welcome :) Please use Github or get in touch with the Preside team on our [Preside Slack](https://presidecms-slack.herokuapp.com/). We could obviously do a lot more with this extension and would be great to collaborate with anyone who has ideas! https://forgebox.io/view/preside-ext-google-analytics Mon, 21 Jul 2025 20:46:09 GMT preside-extensions https://forgebox.io/view/preside-ext-google-analytics Embed PDF files using the Adobe PDF Embed API https://forgebox.io/view/preside-ext-pdf-viewer Mon, 21 Jul 2025 14:16:22 GMT preside-extensions https://forgebox.io/view/preside-ext-pdf-viewer Preside implementation of Apple's MapKit JS mapping system, including integration with the server-side Map and WeatherKit APIs https://forgebox.io/view/preside-ext-apple-services Mon, 28 Apr 2025 13:11:11 GMT preside-extensions https://forgebox.io/view/preside-ext-apple-services An admin map location picker implementing Leaflet maps https://forgebox.io/view/preside-ext-map-picker Thu, 17 Apr 2025 09:35:28 GMT preside-extensions https://forgebox.io/view/preside-ext-map-picker Configure and display photo galleries in Preside https://forgebox.io/view/preside-ext-galleries Tue, 08 Apr 2025 17:09:43 GMT preside-extensions https://forgebox.io/view/preside-ext-galleries Configure multiple Twitter accounts in Preside; interact with the API, including storing and serving tweets locally https://forgebox.io/view/preside-ext-twitter-api Tue, 08 Apr 2025 17:04:06 GMT preside-extensions https://forgebox.io/view/preside-ext-twitter-api # Plausible Analytics for Preside ## Overview This extension provides integration with [Plausible Analytics](https://plausible.io/) for the Preside platform. https://forgebox.io/view/preside-ext-plausible-analytics Tue, 08 Apr 2025 17:01:55 GMT preside-extensions https://forgebox.io/view/preside-ext-plausible-analytics This extension has been incorporated into https://www.forgebox.io/view/preside-ext-apple-services and is no longer supported. https://forgebox.io/view/preside-ext-mapkitjs Tue, 08 Apr 2025 15:32:22 GMT preside-extensions https://forgebox.io/view/preside-ext-mapkitjs # Preside S3 Storage Provider The S3 Storage Provider for Preside provides the best way to integrate S3 with your Preside applications. While you can use native Lucee S3 mappings, this method has the following advantages: * More intuitive to configure * Public/Private asset uploads are taken care of with precise ACL setting * Local file cache configurable with Cachebox The provider is pretty much feature complete, but should be considered BETA at the time of this writing. ## Installation ```box install preside-ext-s3-storage-provider``` ## Configuration ### Using as your default storage provider for the asset manager To configure the provider for use throughout the asset manager, you will need to set your S3 credentials and bucket name (at a minimum). These can either be set directly in your Config.cfc (not recommended), or injected using environment variables. The settings are: ```cfc settings.s3StorageProvider = { accessKey = "" // required, i.e. your S3 access key , secretKey = "" // required, i.e. your S3 secret access key , bucket = "" // required, e.g. 'my-unique-s3-bucket' , region = "" // optional, e.g. eu-west-2 (default is us-east-1) , subpath = "" // optional, e.g. /sub/path/in/bucket , rootUrl = "" // optional, e.g. https://custom.domain.com/public" }; ``` These can be injected using the following environment variables (e.g. if deploying with docker): ``` PRESIDE_S3_ASSETS_ACCESS_KEY PRESIDE_S3_ASSETS_SECRET_KEY PRESIDE_S3_ASSETS_REGION PRESIDE_S3_ASSETS_BUCKET PRESIDE_S3_ASSETS_SUBPATH PRESIDE_S3_ASSETS_URL ``` ## Caching The extension setups up a cachebox cache named, `s3StorageProviderCache`, to cache binary file downloads from S3. The default is a `DiskCache` in the temp directory with a `2 hour` timeout and max `500` objects. If you wish to override this, simply configure your own `s3StorageProviderCache` in your application's `Cachebox.cfc`. For reference, here are the settings we have used: ```cfc { objectStore = "DiskStore" , objectDefaultTimeout = 120 , objectDefaultLastAccessTimeout = 0 , useLastAccessTimeouts = false , reapFrequency = 60 , freeMemoryPercentageThreshold = 0 , evictionPolicy = "LFU" , evictCount = 200 , maxObjects = 500 , directoryPath = GetTempDirectory() & "/.s3Cache" , autoExpandPath = false } ``` ## Using for non-asset-manager storage If you have configured storage providers that are for use outside of the asset manager ([see documentation](https://docs.preside.org/devguides/assetmanager.html#overriding-the-default-storage-location)), you can change them to use the S3 Storage Provider in your application's `/config/Wirebox.cfc`. For example: ```cfc component extends="preside.system.config.WireBox" { public void function configure() { super.configure(); map( "myCustomStorageProvider" ).asSingleton().to( "s3StorageProvider.services.S3StorageProvider" ).noAutoWire().initWith( s3bucket = "" // your settings here , s3accessKey = "" // your settings here , s3secretKey = "" // your settings here , s3region = "" // your settings here , s3rootUrl = "" // your settings here , s3subpath = "" // your settings here ); } } ``` # Contributing Contribution in all forms is very welcome. Use Github to create pull requests for tests, logic, features and documentation. Or, get in touch over at Preside's slack team and we'll be happy to help and chat: [https://presidecms-slack.herokuapp.com/](https://presidecms-slack.herokuapp.com/). https://forgebox.io/view/preside-ext-s3-storage-provider Wed, 02 Apr 2025 11:30:01 GMT preside-extensions https://forgebox.io/view/preside-ext-s3-storage-provider # Preside calendar view extension The Calendar View extension allows developers to present date/time based preside object data in calendar view. The extension builds upon both [Full Calendar](https://fullcalendar.io/) and [Bootstrap year Calendar](https://www.bootstrap-year-calendar.com/), both open source JavaScript calendar tools, and provides Preside hooks to make it super convenient. ## Install Requires **Preside 10.9.0** or higher. Install with: ```bash box install preside-ext-calendar-view ``` ## Rendering a calendar The extension provides a helper method for your handlers and views, `objectCalendarView()`: ```cfm #objectCalendarView( objectName="my_object", args=options )# ``` Current arguments are: * `eventAspectRatio`: controls the width to height ratio of a day block in the calendar. The default is 2. * `allowFilter`: whether or not to show the favourite filters bar above the calendar (rules engine filter favourites) * `calendarView`: which js calendar to show. Use `calendarView=year` to show the [Bootstrap year Calendar](https://www.bootstrap-year-calendar.com/), or ommit/leave blank to use [Full Calendar](https://fullcalendar.io/docs/v3) (default) * `publicView`: to render events for public audience, i.e. non-Admin users. This will hide admin favourite filter from being rendered, hence `allowFilter` is not needed (and will be ignored) when this is set * `publicFormFilter`: path to public form filter. This will render form filter above the calendar ## Decorating your object In order for the calendar view to know how to render your object data, you must decorate your object with some special attributes: ### Admin view ```cfc /** * @calendarStartDateField start_date * @calendarEndDateField end_date * @calendarSelectFields label,type,status */ component { // ... } ``` * `calendarStartDateField`: (required) tells the extension what field to use for the * `calendarEndDateField`: (required) tells the extension what field to use for the end date (can be the same as the start date) * `calendarSelectFields` (optional, default is just the label field) tells the extension what fields to select when fetching data. These fields can then be used in custom renders for a calendar event (see below). ### Public view ```cfc /** * @calendarStartDateField start_date * @calendarEndDateField end_date * @calendarPublicSelectFields id,name,event_type.label as event_type,slug,group_concat( distinct region.id ) as region_ids * @calendarPublicHandler admin.appEventViewer * @calendarLinkKey appEventSlug:slug */ component { // ... } ``` * `calendarStartDateField` & `calendarEndDateField`: (required) same usage as per Admin endpoint * `calendarPublicSelectFields`: (required) fields to select when fetching data. Define as how you would for selectFields. These fields can then be used in custom renders for a calendar event * `calendarPublicHandler`: (required) path to custom handler endpoint which contains rendering functions for public view. * `calendarLinkKey` (optional, needed to render public event link) this builds custom URL. The notion in the example will be used in `event.buildAdminLink( appEventSlug={recordid} )` with additional {recordid} replacement with record `slug` field in `processRecordsForCalendar()` ## Customizing ### Admin view The Calendar View extension uses the [Data Manager customization system](https://docs.preside.org/devguides/datamanager/customization.html) to allow you to make per-object and global customisations of calendar views. Customizations are focused on how to fetch and _what_ data is fetched from the system to populate the calendar. Customizations are: * `buildAjaxCalendarViewLink` Allows you to take over the logic for building the ajax link that will fetch records * `getAdditionalQueryStringForBuildAjaxCalendarViewLink` Similar to `buildAjaxCalendarViewLink`, but allows you to just add query string params to the URL. Often used in conjunction with `preFetchRecordsForCalendarViewListing` or `preFetchRecordsForGridListing`. * `preFetchRecordsForCalendarViewListing` Run before calling `selectData`. The `args` struct can be added to/ modified to change `selectData()` arguments, i.e. add additional filters, etc. * `processRecordsForCalendar` This customization is given `args.records` result from `selectData` and should return an array of structs that will be passed back to the calendar * `addCalendarEventFields` This customization is run _per record_ and allows you to modify / add fields to a single record that will be returned to the calendar. This will not be used if you implement `processRecordsForCalendar`. In addition, the extension also attempts to hook into core grid listing customizations so that you can use the same filter logic, etc. in your calendar as you do with your grid: * [getAdditionalQueryStringForBuildAjaxListingLink](https://docs.preside.org/devguides/datamanager/customization/getAdditionalQueryStringForBuildAjaxListingLink.html) * [postFetchRecordsForGridListing](https://docs.preside.org/devguides/datamanager/customization/postFetchRecordsForGridListing.html) ### Public view Customisation of the following functions has to be in the handler as defined in the object's `@calendarPublicHandler`: * `getAdditionalFiltersForAjaxCalendarPublicView`: required function for filtering records, if custom form filter is defined for `publicFormFilter` * `processRecordsForCalendar`: same usage as admin view * `addCalendarEventFields`: same usage as admin view All [Full Calendar](https://fullcalendar.io/) configuration options can be passed in as dynamic values to the calendar initialisation. e.g. adding the month, agendaWeek and agendaDay views on the left side. ```cfc objectCalendarView( objectName = "myPresideObject" , args = { config = { header = { left = "month,agendaWeek,agendaDay" , center = "title" , right = "today prev,next" } } } ) ``` ## Public view - multiple sources Can be setup via interceptor with the function `preRenderCalendarViewlet( ... )` to define additional sources endpoint, and pass it via `includeData`, i.e. ```cfc event.includeData( { additionalUrls = interceptData.additionalUrls } ); ``` Configuration for [Bootstrap year Calendar](https://www.bootstrap-year-calendar.com/) can be passed using `yearConfig`. Currently only `monthCalendarUrl` is supported which can be used to provide a base url to link to [Full Calendar](https://fullcalendar.io/). For example, to link to a particular day you could use: ```cfc objectCalendarView( objectName = "myPresideObject" , args = { calendarView = "year" , yearConfig = { monthCalendarUrl = "www.yoursite.com/page-with-full-calendar/?defaultView=basicDay&defaultDate=" } } ) ``` The selected day will be appended to the url. ## Calendar event fields When returning an array of structs for the calendar, all the fields that are implemented by FullCalendar are supported. See docs for full details: https://fullcalendar.io/docs/event-object. In _addition_, the extension also allows you to set a `htmlTitle` field that allows you more flexibility for rendering the title of a calendar item (the default implementation of `title` escapes any html). ## Calendar event colour codes You can setup colour codes for different event types using this component. To use this, enable feature `calendarManageColour` This comes with a helper function `getCalendarItemColoursByLabel()` which can be called in `processRecordsForCalendar()` # Contributing Contribution in all forms is very welcome. Use Github to create pull requests for tests, logic, features and documentation. Or, get in touch over at Preside's slack team and we'll be happy to help and chat: [https://presidecms-slack.herokuapp.com/](https://presidecms-slack.herokuapp.com/). https://forgebox.io/view/preside-ext-calendar-view Mon, 24 Feb 2025 14:30:15 GMT preside-extensions https://forgebox.io/view/preside-ext-calendar-view # Sentry Integration for Preside ## Overview This extension includes the bugLogService.cfc originally from the [BugLogHQ project](https://github.com/oarevalo/BugLogHQ) and uses it to send errors to BugLogHQ from the Preside platform. ## Installation The extension can be [installed through](https://forgebox.io/view/preside-ext-bugloghq). ```sh box install preside-ext-bugloghq ``` ## Configuration The extension is configured using environment variables: ```sh PRESIDE_BUGLOG_LISTENER_URL=https://your_bugLog_instance/bugLog/listeners/bugLogListenerREST.cfm PRESIDE_BUGLOG_APP_NAME=your_app_name_to_appear_in_buglog #e.g. myApp_DEV or MyApp_PROD PRESIDE_BUGLOG_EMAIL_RECIPIENTS=fixer@bug.com PRESIDE_BUGLOG_EMAIL_SENDER=siteadmin@myApp.com ``` Once installed and configured the extension will send error reports to your BugLogHQ instance each time an error is raised in Preside. These will be labelled with the app name defined in the env varsa above. If BugLogHQ is unavailable an email report will be sent to the email recipients defined above. https://forgebox.io/view/preside-ext-bugloghq Mon, 27 May 2024 10:10:39 GMT preside-extensions https://forgebox.io/view/preside-ext-bugloghq # External Storage for DB Columns ## About This _experimental_ extension allows you to use a Preside storage provider as private storage for a database column (on a Preside object). This could be useful in situations where you have a table with a lot of rows and one large column that is read infrequently. Putting the storage of this column in an S3 bucket, for example, could have a cost benefit, keeping database storage lower and utilising more cheap storage in its place. ## Howto With this extension installed (`box install preside-ext-external-dbcolumn-storage`), you annotate your preside object property with a `externalStorageProvider` attribute whose value is a configured storage provider in wirebox: ```cfc // a preside object component { property name="content" externalStorageProvider="myStorageProvider"; } ``` ```cfc // WireBox.cfc // N.B. for illustrative purposes only - settings.mystorageprovider is fictional and would be up to you to configure // here we are using the s3 storage provider, but could be another storage provider altogether binder.map( "myStorageProvider" ).asSingleton().to( "app.extensions.preside-ext-s3-storage-provider.services.S3StorageProvider" ).noAutoWire().initWith( s3bucket = settings.mystorageprovider.bucket , s3accessKey = settings.mystorageprovider.accessKey , s3secretKey = settings.mystorageprovider.secretKey , s3region = settings.mystorageprovider.region , s3subPath = "/mystorageprovier" ); ``` ## Known limitations This extension is in an ALPHA state. it currently does not: * Delete objects from the storage provider once their parent record is deleted * Delete objects from the storage provider when the value of the column changes ## License This project is licensed under the GPLv2 License - see the [LICENSE.txt](https://github.com/pixl8/preside-ext-external-dbcolumn-storage/blob/stable/LICENSE.txt) file for details. ## Authors The project is maintained by [The Pixl8 Group](https://www.pixl8.co.uk). ## Code of conduct We are a small, friendly and professional community. For the eradication of doubt, we publish a simple [code of conduct](https://github.com/pixl8/preside-ext-external-dbcolumn-storage/blob/stable/CODE_OF_CONDUCT.md) and expect all contributors, users and passers-by to observe it. https://forgebox.io/view/preside-ext-external-dbcolumn-storage Tue, 14 May 2024 12:51:22 GMT preside-extensions https://forgebox.io/view/preside-ext-external-dbcolumn-storage # Preside admin first time login lockdown ## Summary This extension prevents abuse of the first time user setup feature of the Preside admin. It has been designed to work with any version of Preside and can be installed without necessitating any Preside upgrade. ## License This project is licensed under the GPLv2 License - see the [LICENSE.txt](https://github.com/pixl8/Preside-CMS/blob/stable/LICENSE.txt) file for details. ## Authors The project is maintained by [The Pixl8 Group](https://www.pixl8.co.uk). ## Code of conduct We are a small, friendly and professional community. For the eradication of doubt, we publish a simple [code of conduct](https://github.com/pixl8/Preside-CMS/blob/stable/CODE_OF_CONDUCT.md) and expect all contributors, users and passers-by to observe it. https://forgebox.io/view/preside-ext-first-time-login-lockdown Fri, 10 May 2024 08:38:13 GMT preside-extensions https://forgebox.io/view/preside-ext-first-time-login-lockdown # HTML Import This extension offers a straightforward solution for importing HTML content into your Preside pages. ## Getting started The zip file must contain at least one *.html file and the folder for images if any. ``` ├── index.html └── images ├── hello.jpg └── world.png ``` ## License This project is licensed under the GPLv2 License - see the LICENSE.txt file for details. ## Code of conduct We are a small, friendly and professional community. For the eradication of doubt, we publish a simple code of conduct and expect all contributors, users and passers-by to observe it. https://forgebox.io/view/preside-ext-html-import Mon, 22 Apr 2024 07:19:40 GMT preside-extensions https://forgebox.io/view/preside-ext-html-import # EXTENSIONNAME Supply a helpful README here. https://forgebox.io/view/preside-ext-scribe Mon, 01 Apr 2024 09:21:56 GMT preside-extensions https://forgebox.io/view/preside-ext-scribe # Preside Extension Editor.js A simple Editor.js extension for Preside. https://forgebox.io/view/preside-ext-editorjs Fri, 15 Mar 2024 07:40:04 GMT preside-extensions https://forgebox.io/view/preside-ext-editorjs # Email Log Performance An extension to help with statistics performance for application sending a lot of email. ALPHA state, nothing to see here yet. https://forgebox.io/view/preside-ext-email-log-performance Wed, 13 Mar 2024 14:52:08 GMT preside-extensions https://forgebox.io/view/preside-ext-email-log-performance # ClamAV AntiVirus for Preside ## Overview This extension provides anti virus scanning using ClamAV (unix servers only) for files uploaded to Preside. See [Wiki](https://github.com/pixl8/preside-ext-clamav/wiki) for complete usage documentation. ## Installation Install the extension to your application via either of the methods detailed below (Git submodule / CommandBox) and then enable the extension by opening up the Preside developer console and entering: ``` extension enable preside-ext-clamav reload all ``` ### CommandBox (box.json) method From the root of your application, type the following command: ``` box install preside-ext-clamav ``` ### Git Submodule method From the root of your application, type the following command: ``` git submodule add https://github.com/pixl8/preside-ext-sentry.git application/extensions/preside-ext-clamav ``` https://forgebox.io/view/preside-ext-clamav Thu, 22 Feb 2024 10:50:45 GMT preside-extensions https://forgebox.io/view/preside-ext-clamav # Sentry Integration for Preside ## Overview This extension provides integration with [Sentry](https://sentry.io/) for the Preside platform. ## Usage Once installed (see below), you will need to configure your Sentry API key for your application. This can be achieved a number of ways: * Injecting a configuration variable, `SENTRY_API_KEY` (recommended). This can be achieved with a regular system environment variable named `PRESIDE_SENTRY_API_KEY`, or by adding a `SENTRY_API_KEY` entry to the `/application/config/.injectedConfiguration` json file * Setting an application variable `application.SENTRY_API_KEY={yourkey}` In addition, you can optionally specify an environment that Sentry can use. This way you are able to distinguish within the same Sentry project different server environments, e.g. production, staging, development, ... Note: Environments are supported as of Sentry version 9. * Injecting a configuration variable, `SENTRY_ENVIRONMENT` (recommended). This can be achieved with a regular system environment variable named `PRESIDE_SENTRY_ENVIRONMENT`, or by adding a `SENTRY_ENVIRONMENT` entry to the `/application/config/.injectedConfiguration` json file * Setting an application variable `application.SENTRY_ENVIRONMENT={yourenvironment}` ## Installation Install the extension to your application via either of the methods detailed below (Git submodule / CommandBox) and then enable the extension by opening up the Preside developer console and entering: ``` extension enable preside-ext-mailgun reload all ``` ### CommandBox (box.json) method From the root of your application, type the following command: ``` box install preside-ext-sentry ``` ### Git Submodule method From the root of your application, type the following command: ``` git submodule add https://github.com/pixl8/preside-ext-sentry.git application/extensions/preside-ext-sentry ``` https://forgebox.io/view/preside-ext-sentry Thu, 22 Feb 2024 10:47:11 GMT preside-extensions https://forgebox.io/view/preside-ext-sentry # Preside IP Geolocation APIs Extension Preside extension to allow application developers to get all geolocation information about an IP address in a number of different formats. Mainly developed for use with the https://extreme-ip-lookup.com/ IP Geolocation service but can be adapted to another provider. Simply configure the API settings and that should be all you need. Examples are given in the CMS Admin Settings form. ## Installation Install the extension to your application via either of the methods detailed below (Git submodule / CommandBox + ForgeBox) ### Git Submodule method From the root of your application, type the following command: git submodule add https://github.com/nodoherty/preside-ext-ip-geolocation-apis.git application/extensions/preside-ext-ip-geolocation-apis ### CommandBox (box.json) method From the root of your application type the following command: box install preside-ext-ip-geolocation-apis From the Preside CMS developer console (using the back tick ` key) reload the application: reload all ### Enabling the extension Once the files are installed, enable the extension by reloading the application: reload all --force ## Usage See the included handler `ipGeolocation.cfc` for examples of calling directly via ColdFusion server code or via AJAX https://forgebox.io/view/preside-ext-ip-geolocation-apis Fri, 27 Oct 2023 09:23:00 GMT preside-extensions https://forgebox.io/view/preside-ext-ip-geolocation-apis # Preside Extension: Dump logs This is an extension for [Preside](https://www.presidecms.com) to provide the ability to log data dumps. Visually it is similar to the existing core functionality of Error logs. In detail the extension includes the following: * Possibility to dump data (think "writeDump" / "cfdump") to a file that can be examined * Preside Admin > System > Dump Logs * Service DumpLogService with method _dumplog_ (pass in whatever you like) * helper method _dumplog_ (use it in you handlers and views) ## Usage Within a handler or view, use the following dumpLog( myvar ); ... dumpLog( myvar=myvar ); ... dumpLog( a=1, b=server, c=myvar ); ... Or use the service, e.g. within your own service component { property name="dumpLogService" inject="dumpLogService"; function myFunction() { ... dumpLogService.dumpLog( myvar ); ... dumpLogService.dumpLog( myvar=myvar ); ... dumpLogService.dumpLog( a=1, b=server, c=myvar ); ... } } Head over to Preside Admin > System > Dump Logs to check the dumps there. If you want to disable the feature, use the following in your Config.cfc settings.features.dumpLogs = false; ## Installation Install the extension to your application via either of the methods detailed below (Git submodule / CommandBox) and then enable the extension by opening up the Preside developer console and entering: extension enable preside-ext-dumplogs reload all ### Git Submodule method From the root of your application, type the following command: git submodule add https://bitbucket.org/jjannek/preside-ext-dumplogs.git application/extensions/preside-ext-dumplogs ### CommandBox (box.json) method From the root of your application, type the following command: box install preside-ext-dumplogs ## Contribution Feel free to fork and pull request. Any other feedback is also welcome - preferable on the PresideCMS slack channel. https://forgebox.io/view/preside-ext-dumplogs Fri, 20 Oct 2023 14:38:42 GMT preside-extensions https://forgebox.io/view/preside-ext-dumplogs Use annotation in preside object to declare quick filter to replace advanced filter of an object https://forgebox.io/view/preside-ext-maysoft-quick-filter Tue, 05 Sep 2023 07:49:19 GMT preside-extensions https://forgebox.io/view/preside-ext-maysoft-quick-filter # Empty Email Layouts The Empty Email Layout extension provides you with just that - an empty email layout! You can use this to configure completely custom HTML layouts. Currently in alpha. ## License This project is licensed under the GPLv2 License - see the [LICENSE.txt](https://github.com/pixl8/preside-ext-empty-email-layouts/blob/stable/LICENSE.txt) file for details. ## Authors The project is maintained by [The Pixl8 Group](https://www.pixl8.co.uk). The lead developers is [Dominic Watson](https://github.com/DominicWatson). ## Code of conduct We are a small, friendly and professional community. For the eradication of doubt, we publish a simple [code of conduct](https://github.com/pixl8/preside-ext-empty-email-layouts/blob/stable/CODE_OF_CONDUCT.md) and expect all contributors, users and passers-by to observe it. https://forgebox.io/view/preside-ext-empty-email-layouts Fri, 18 Aug 2023 13:17:35 GMT preside-extensions https://forgebox.io/view/preside-ext-empty-email-layouts # Preside Performance Analyser The *Preside Performance Analyser* aims to bring [Zac Spitzer's](https://github.com/zspitzer) awesome [Lucee Performance Analyser extension](https://github.com/zspitzer/lucee-performance-analyzer/) to Preside, with added Preside goodness. This is currently a work in progress and nothing to see here :) ## Versioning We use [SemVer](https://semver.org) for versioning. For the versions available, see the [tags on this repository](https://github.com/pixl8/preside-ext-performance-analyser/releases). Project releases can also be found and installed from [Forgebox](https://forgebox.io/view/preside-ext-performance-analyser) ## License This project is licensed under the GPLv2 License - see the [LICENSE.txt](https://github.com/pixl8/preside-ext-performance-analyser/blob/stable/LICENSE.txt) file for details. ## Authors The project is maintained by [The Pixl8 Group](https://www.pixl8.co.uk). The lead developers are [Dominic Watson](https://github.com/DominicWatson) and [Zac Spitzer](https://github.com/zspitzer). ## Code of conduct We are a small, friendly and professional community. For the eradication of doubt, we publish a simple [code of conduct](https://github.com/pixl8/preside-ext-performance-analyser/blob/stable/CODE_OF_CONDUCT.md) and expect all contributors, users and passers-by to observe it. https://forgebox.io/view/preside-ext-performance-analyser Fri, 12 May 2023 21:16:15 GMT preside-extensions https://forgebox.io/view/preside-ext-performance-analyser # Smart Throttler: Request limiting for Preside Applications This extension allows you to add finer control of request throttling for your Preside applications: 1. Limit the max number of requests Preside will process 2. Set a maximum queue size for requests over the limit 3. Define URL paths that will *bypass the queue* - i.e. healthchecks 4. Define URL paths that should be treated as a priority 5. Define whether or not to prioritise logged in users (web and admin) The project is currently in an ALPHA state. ## Configuration Configuration of the extension can provided either through environment variables, or by direct settings in your application's Config.cfc. Variables to set: * `maxActiveRequests`: Maximum number of active requests before queueing requests. Default is `0` which turns off all functionality of this extension * `queueSize`: The maximum number of queued requests. Default is `0`. * `queueTimeout`: The maximum time in seconds that a request can be in the queue before timing out. Default is `50`. * `failureStatusCode`: Status code to use when either the queue is full, or requests timeout. Default is `503`. * `sleepInterval`: How long queued threads sleep for before checking their status again (in ms). Default is `50`. * `skipPaths`: An array of URL paths that can bypass the queue entirely. These are matched with a "startsWith" pattern so an incoming `/api/v2/events/` request matches an `/api/` path * `priorityPaths`: An array of URL paths that will be placed in the priority queue and processed before "standard" requests. These are matched with a "startsWith" pattern so an incoming `/api/v2/events/` request matches an `/api/` path * `prioritiseUsers`: Boolean, whether or not to put logged in user requests into the priority queue. Default is `true`. * `prioritiseAdmins`: Boolean, whether or not to put logged in admin user requests into the priority queue. Default is `false`. ### Using environment variables The following environment variables can be set to control the configuration options, above: * `SMARTTHROTTLER_MAX_ACTIVE_REQUESTS` * `SMARTTHROTTLER_QUEUE_SIZE` * `SMARTTHROTTLER_QUEUE_TIMEOUT` * `SMARTTHROTTLER_FAILURE_STATUS_CODE` * `SMARTTHROTTLER_SLEEP_INTERVAL` * `SMARTTHROTTLER_SKIP_PATHS` (use a string list of paths, e.g. "/alive,/metrics") * `SMARTTHROTTLER_PRIORITY_PATHS` (use a string list of paths, e.g. "/api,/login") * `SMARTTHROTTLER_PRIORITISE_USERS` * `SMARTTHROTTLER_PRIORITISE_ADMINS` See [Configuring Preside](https://docs.preside.org/devguides/config.html#injecting-environment-variables) page in Preside docs for a guide to injecting environment variables. ### Using Config.cfc ```cfc settings.smartThrottler.maxActiveRequests = 20; settings.smartThrottler.queueSize = 100; settings.smartThrottler.queueTimeout = 50; settings.smartThrottler.failureStatusCode = 503; settings.smartThrottler.sleepInterval = 20; settings.smartThrottler.skipPaths = [ "/alive", "/metrics" ]; // must be an array settings.smartThrottler.priorityPaths = [ "/login/", "/admin/" ]; // must be an array settings.smartThrottler.prioritiseUsers = true; settings.smartThrottler.prioritiseAdmins = false; ``` ## Versioning We use [SemVer](https://semver.org) for versioning. For the versions available, see the [tags on this repository](https://github.com/pixl8/preside-ext-smart-throttler/releases). Project releases can also be found and installed from [Forgebox](https://forgebox.io/view/preside-ext-smart-throttler) ## License This project is licensed under the GPLv2 License - see the [LICENSE.txt](https://github.com/pixl8/preside-ext-smart-throttler/blob/stable/LICENSE.txt) file for details. ## Authors The project is maintained by [The Pixl8 Group](https://www.pixl8.co.uk). The lead developer is [Dominic Watson](https://github.com/DominicWatson) and the project is supported by the community ([view contributors](https://github.com/pixl8/preside-ext-smart-throttler/graphs/contributors)). ## Code of conduct We are a small, friendly and professional community. For the eradication of doubt, we publish a simple [code of conduct](https://github.com/pixl8/preside-ext-smart-throttler/blob/stable/CODE_OF_CONDUCT.md) and expect all contributors, users and passers-by to observe it. https://forgebox.io/view/preside-ext-smart-throttler Fri, 05 May 2023 11:26:41 GMT preside-extensions https://forgebox.io/view/preside-ext-smart-throttler This extension provides a widget that you can attach to any Preside page, to add a fluffy snowflakes effect! https://forgebox.io/view/preside-ext-snow-fx Tue, 29 Nov 2022 14:46:47 GMT preside-extensions https://forgebox.io/view/preside-ext-snow-fx # Preside Extension: Development Helpers This is an extension for [Preside](https://www.preside.org) to provide some useful small helpers for local development. * an easy way for developers to login to the Preside Admin locally with one click * quick links to reload the app and show the Preside console * ability to log data dumps Attention: Use with extreme caution and on your own risk. This is purely intended to be used on local developer machines, not in any other environment. ## Installation From the root of your application, type the following command in a terminal: box install preside-ext-dev-helpers --saveDev ## Usage ### One-Click Local Login Within your application's Config.cfc, enable it: settings.features.oneClickLocalLogin.enabled = true; The Admin Login changes (only locally) adding a simple button to click for login (no credentials needed). The logged-in user has sysadmin permissions. The traditional login is still available optionally. (This makes use of the [Preside Admin Login Provider](https://docs.preside.org/devguides/adminloginproviders.html) concept). ### Preside Admin Quick Links Within your application's Config.cfc, enable it: settings.features.devQuickLinks.enabled = true; Within the Preside Admin on the right side of the bread crumb navigation, you will find 2 links: * console - toggles the Developer console (tough to get to on some non-english keyboards) * re-init - does a fwreinit (framework reload) on the current page ### Dump Logs In order to use dump logs, enable the feature in your Config.cfc: settings.features.dumpLogs.enabled = true; Within a handler or view, use the following dumpLog( myvar ); ... dumpLog( myvar=myvar ); ... dumpLog( a=1, b=server, c=myvar ); ... Or use the service, e.g. within your own service component { property name="dumpLogService" inject="dumpLogService"; function myFunction() { ... dumpLogService.dumpLog( myvar ); ... dumpLogService.dumpLog( myvar=myvar ); ... dumpLogService.dumpLog( a=1, b=server, c=myvar ); ... } } If you are using Preside 10.11 or greater you can make use of a nice little short cut. Instead of injecting the dumplogservice you can directly call the dumplog method as follows: $helpers.dumpLog( myvar ); This works on all services that are annotated as being a presideservice. Head over to Preside Admin > System > Dump Logs to check the dumps there. ## Contribution Feel free to fork and pull request. Any other feedback is also welcome - preferable on the Preside Slack channel. https://forgebox.io/view/preside-ext-dev-helpers Fri, 08 Jul 2022 14:58:11 GMT preside-extensions https://forgebox.io/view/preside-ext-dev-helpers # Apache Tika for Preside Apache Tika service for extracting document metadata from pdfs, word docs, etc. https://forgebox.io/view/preside-ext-tika Fri, 27 May 2022 19:12:19 GMT preside-extensions https://forgebox.io/view/preside-ext-tika # Pirate Supply a helpful README here. https://forgebox.io/view/preside-ext-pirate Mon, 02 May 2022 09:50:25 GMT preside-extensions https://forgebox.io/view/preside-ext-pirate # Discourse topic sync for Preside This extension connects a discourse instance and syncs topics into your Preside application. From here you can index topics to build an integrated solution with discourse and your Preside website. ## Installation From a commandline at the root of your application: ``` box install preside-ext-discourse-sync ``` ## Configuration Once installed, login to the Preside admin and head to **System -> Settings -> Discourse Sync Credentials**. Enter your discourse base URL, e.g. https://community.preside.org, the API key that you generate within the Discourse admin and a Discourse username that all API requests will be authenticated with (make sure that user has permissions to get the data you need!). Save these settings. Head over to **System -> Task manager** and find the discourse sync tasks. Run the **Sync categories** task to pull down all the categories from Discourse. If you want to limit the topics that you sync to certain categories, then head back to the discourse settings page and choose the categories that you want. Finally, run the **Sync topics** task to sync down any topics you want in your system. ## Usage What you do with the data is now up to you! You could create a page type that lists topics that are filtered by a rules engine filter, or create widgets that do the same thing. All up to you :) ## Contributing Pull requests, issues and ideas are all welcome :) Please use Github or get in touch with the Preside team on our [Preside Slack](https://presidecms-slack.herokuapp.com/). https://forgebox.io/view/preside-ext-discourse-sync Fri, 25 Mar 2022 16:07:39 GMT preside-extensions https://forgebox.io/view/preside-ext-discourse-sync # Mailjet Integration for Preside [](https://travis-ci.org/pixl8/preside-ext-mailjet) ## Overview This extension provides integration for [Mailjet](https://www.mailjet.com/) with Preside's email centre (Preside 10.8 and above). Currently, the extension provides: * A Message Centre service provider with configuration for sending email through mailjet's API * A mailjet webhook endpoint (`/mailjet/hooks/`) for receiving and processing mailjet webhooks for delivery & bounce notifications, etc. See the [wiki](https://github.com/pixl8/preside-ext-mailjet/wiki) for further documentation. ## Installation From the root of your application, type the following command (using [CommandBox](https://www.ortussolutions.com/products/commandbox)): ``` box install preside-ext-mailjet ``` ### Additional step for Preside 10.8 and below If you are not already on Preside 10.9 or above, you'll need to enable the extension by opening up the Preside developer console and entering: ``` extension enable preside-ext-mailjet reload all ``` https://forgebox.io/view/preside-ext-mailjet Mon, 28 Feb 2022 14:17:47 GMT preside-extensions https://forgebox.io/view/preside-ext-mailjet # InxMail SMTP Provider The InxMail SMTP provider allows you to use the [InxMail SMTP Relay service](https://www.inxmail.com/products/mail-relay) with Preside Email Center. Once installed, the extension will add an InxMail tab to your email settings page. Configure your SMTP credentials and API keys and you are good to go. ## Permissions The extension adds the following admin permission key: `inxmailBounces.bounces`. This is used to control access to the InxMail blocklist management screens from within the Preside admin. The permission is added to the default Preside `sysadmin` role but _you will need to add the key to any other admin user roles who you wish to have access to this feature_. ## Recommendations We recommend that you set the following feature flag in your application's config.cfc if you are using this extension to send mail: ```cfc settings.features.emailDeliveryStats.enabled = false; ``` The reason for this is that we do not have actual delivery statistics from InxMail - having delivery stats in the Preside UI leads to confusion and mistrust from the user. **Note** This feature flag is effective as of **Preside 10.12.0-SNAPSHOT6447**. ## License This project is licensed under the GPLv2 License - see the [LICENSE.txt](https://github.com/pixl8/preside-ext-inxmail/blob/stable/LICENSE.txt) file for details. ## Authors The project is maintained by [The Pixl8 Group](https://www.pixl8.co.uk). The lead developer is [Dominic Watson](https://github.com/DominicWatson) and the project is supported by the community ([view contributors](https://github.com/pixl8/preside-ext-inxmail/graphs/contributors)). ## Code of conduct We are a small, friendly and professional community. For the eradication of doubt, we publish a simple [code of conduct](https://github.com/pixl8/preside-ext-inxmail/blob/stable/CODE_OF_CONDUCT.md) and expect all contributors, users and passers-by to observe it. https://forgebox.io/view/preside-ext-inxmail Wed, 13 Oct 2021 09:26:25 GMT preside-extensions https://forgebox.io/view/preside-ext-inxmail