Add new functions to custom-api widget

* feat: custom-api multiple API queries

* fix template check

* refactor

* Update implementation & docs

* Swap statement

* Update docs

---------

Co-authored-by: Svilen Markov <7613769+svilenmarkov@users.noreply.github.com>

README.md

@@ -264,59 +264,31 @@ Glance can also be installed through the following 3rd party channels:
 
 <br>
 
-## Building from source
+## Common issues
-
-Choose one of the following methods:
-
 <details>
-<summary><strong>Build binary with Go</strong></summary>
+<summary><strong>Requests timing out</strong></summary>
-<br>
 
-Requirements: [Go](https://go.dev/dl/) >= v1.23
+The most common cause of this is when using Pi-Hole, AdGuard Home or other ad-blocking DNS services, which by default have a fairly low rate limit. Depending on the number of widgets you have in a single page, this limit can very easily be exceeded. To fix this, increase the rate limit in the settings of your DNS service.
 
-To build the project for your current OS and architecture, run:
+If using Podman, in some rare cases the timeout can be caused by an unknown issue, in which case it may be resolved by adding the following to the bottom of your `docker-compose.yml` file:
-
+```yaml
-```bash
+networks:
-go build -o build/glance .
+  podman:
+    external: true
 ```
-
-To build for a specific OS and architecture, run:
-
-```bash
-GOOS=linux GOARCH=amd64 go build -o build/glance .
-```
-
-[*click here for a full list of GOOS and GOARCH combinations*](https://go.dev/doc/install/source#:~:text=$GOOS%20and%20$GOARCH)
-
-Alternatively, if you just want to run the app without creating a binary, like when you're testing out changes, you can run:
-
-```bash
-go run .
-```
-<hr>
 </details>
 
 <details>
-<summary><strong>Build project and Docker image with Docker</strong></summary>
+<summary><strong>Broken layout for markets, bookmarks or other widgets</strong></summary>
-<br>
 
-Requirements: [Docker](https://docs.docker.com/engine/install/)
+This is almost always caused by the browser extension Dark Reader. To fix this, disable dark mode for the domain where Glance is hosted.
+</details>
 
-To build the project and image using just Docker, run:
+<details>
+<summary><strong>cannot unmarshal !!map into []glance.page</strong></summary>
 
-*(replace `owner` with your name or organization)*
+The most common cause of this is having a `pages` key in your `glance.yml` and then also having a `pages` key inside one of your included pages. To fix this, remove the `pages` key from the top of your included pages.
 
-```bash
-docker build -t owner/glance:latest .
-```
-
-If you wish to push the image to a registry (by default Docker Hub), run:
-
-```bash
-docker push owner/glance:latest
-```
-
-<hr>
 </details>
 
 <br>
@@ -375,6 +347,63 @@ Feature requests are tagged with one of the following:
 
 <br>
 
+## Building from source
+
+Choose one of the following methods:
+
+<details>
+<summary><strong>Build binary with Go</strong></summary>
+<br>
+
+Requirements: [Go](https://go.dev/dl/) >= v1.23
+
+To build the project for your current OS and architecture, run:
+
+```bash
+go build -o build/glance .
+```
+
+To build for a specific OS and architecture, run:
+
+```bash
+GOOS=linux GOARCH=amd64 go build -o build/glance .
+```
+
+[*click here for a full list of GOOS and GOARCH combinations*](https://go.dev/doc/install/source#:~:text=$GOOS%20and%20$GOARCH)
+
+Alternatively, if you just want to run the app without creating a binary, like when you're testing out changes, you can run:
+
+```bash
+go run .
+```
+<hr>
+</details>
+
+<details>
+<summary><strong>Build project and Docker image with Docker</strong></summary>
+<br>
+
+Requirements: [Docker](https://docs.docker.com/engine/install/)
+
+To build the project and image using just Docker, run:
+
+*(replace `owner` with your name or organization)*
+
+```bash
+docker build -t owner/glance:latest .
+```
+
+If you wish to push the image to a registry (by default Docker Hub), run:
+
+```bash
+docker push owner/glance:latest
+```
+
+<hr>
+</details>
+
+<br>
+
 ## Contributing guidelines
 
 * Before working on a new feature it's preferable to submit a feature request first and state that you'd like to implement it yourself

docs/configuration.md

@@ -9,7 +9,7 @@
 - [Document](#document)
 - [Branding](#branding)
 - [Theme](#theme)
-  - [Themes](#themes)
+  - [Available themes](#available-themes)
 - [Pages & Columns](#pages--columns)
 - [Widgets](#widgets)
   - [RSS](#rss)
@@ -274,7 +274,7 @@ theme:
   contrast-multiplier: 1.1
 ```
 
-### Themes
+### Available themes
 If you don't want to spend time configuring your own theme, there are [several available themes](themes.md) which you can simply copy the values for.
 
 ### Properties
@@ -1292,8 +1292,14 @@ Examples:
 | ---- | ---- | -------- | ------- |
 | url | string | yes | |
 | headers | key (string) & value (string) | no | |
+| method | string | no | GET |
+| body-type | string | no | json |
+| body | any | no | |
 | frameless | boolean | no | false |
+| allow-insecure | boolean | no | false |
 | template | string | yes | |
+| parameters | key (string) & value (string|array) | no | |
+| subrequests | map of requests | no | |
 
 ##### `url`
 The URL to fetch the data from. It must be accessible from the server that Glance is running on.
@@ -1307,12 +1313,89 @@ headers:
   Accept: application/json
 ```
 
+##### `method`
+The HTTP method to use when making the request. Possible values are `GET`, `POST`, `PUT`, `PATCH`, `DELETE`, `OPTIONS` and `HEAD`.
+
+##### `body-type`
+The type of the body that will be sent with the request. Possible values are `json`, and `string`.
+
+##### `body`
+The body that will be sent with the request. It can be a string or a map. Example:
+
+```yaml
+body-type: json
+body:
+  key1: value1
+  key2: value2
+  multiple-items:
+    - item1
+    - item2
+```
+
+```yaml
+body-type: string
+body: |
+  key1=value1&key2=value2
+```
+
 ##### `frameless`
 When set to `true`, removes the border and padding around the widget.
 
+##### `allow-insecure`
+Whether to ignore invalid/self-signed certificates.
+
 ##### `template`
 The template that will be used to display the data. It relies on Go's `html/template` package so it's recommended to go through [its documentation](https://pkg.go.dev/text/template) to understand how to do basic things such as conditionals, loops, etc. In addition, it also uses [tidwall's gjson](https://github.com/tidwall/gjson) package to parse the JSON data so it's worth going through its documentation if you want to use more advanced JSON selectors. You can view additional examples with explanations and function definitions [here](custom-api.md).
 
+##### `parameters`
+A list of keys and values that will be sent to the custom-api as query paramters.
+
+##### `subrequests`
+A map of additional requests that will be executed concurrently and then made available in the template via the `.Subrequest` property. Example:
+
+```yaml
+- type: custom-api
+  cache: 2h
+  subrequests:
+    another-one:
+      url: https://uselessfacts.jsph.pl/api/v2/facts/random
+  title: Random Fact
+  url: https://uselessfacts.jsph.pl/api/v2/facts/random
+  template: |
+    <p class="size-h4 color-paragraph">{{ .JSON.String "text" }}</p>
+    <p class="size-h4 color-paragraph margin-top-15">{{ (.Subrequest "another-one").JSON.String "text" }}</p>
+```
+
+The subrequests support all the same properties as the main request, except for `subrequests` itself, so you can use `headers`, `parameters`, etc.
+
+`(.Subrequest "key")` can be a little cumbersome to write, so you can define a variable to make it easier:
+
+```yaml
+  template: |
+    {{ $anotherOne := .Subrequest "another-one" }}
+    <p>{{ $anotherOne.JSON.String "text" }}</p>
+```
+
+You can also access the `.Response` property of a subrequest as you would with the main request:
+
+```yaml
+  template: |
+    {{ $anotherOne := .Subrequest "another-one" }}
+    <p>{{ $anotherOne.Response.StatusCode }}</p>
+```
+
+> [!NOTE]
+>
+> Setting this property will override any query parameters that are already in the URL.
+
+```yaml
+parameters:
+  param1: value1
+  param2:
+    - item1
+    - item2
+```
+
 ### Extension
 Display a widget provided by an external source (3rd party). If you want to learn more about developing extensions, checkout the [extensions documentation](extensions.md) (WIP).
 
@@ -1330,6 +1413,7 @@ Display a widget provided by an external source (3rd party). If you want to lear
 | url | string | yes | |
 | fallback-content-type | string | no | |
 | allow-potentially-dangerous-html | boolean | no | false |
+| headers | key & value | no | |
 | parameters | key & value | no | |
 
 ##### `url`
@@ -1338,6 +1422,14 @@ The URL of the extension. **Note that the query gets stripped from this URL and
 ##### `fallback-content-type`
 Optionally specify the fallback content type of the extension if the URL does not return a valid `Widget-Content-Type` header. Currently the only supported value for this property is `html`.
 
+##### `headers`
+Optionally specify the headers that will be sent with the request. Example:
+
+```yaml
+headers:
+  x-api-key: ${SECRET_KEY}
+```
+
 ##### `allow-potentially-dangerous-html`
 Whether to allow the extension to display HTML.
 

docs/custom-api.md

@@ -242,6 +242,57 @@ Other operations include `add`, `mul`, and `div`.
 
 <hr>
 
+JSON response:
+
+```json
+{
+  "posts": [
+    {
+      "title": "Exploring the Depths of Quantum Computing",
+      "date": "2023-10-27T10:00:00Z"
+    },
+    {
+      "title": "A Beginner's Guide to Sustainable Living",
+      "date": "2023-11-15T14:30:00+01:00"
+    },
+    {
+      "title": "The Art of Baking Sourdough Bread",
+      "date": "2023-12-03T08:45:22-08:00"
+    }
+  ]
+}
+```
+
+To parse the date and display the relative time (e.g. 2h, 1d, etc), you would use the following:
+
+```
+{{ range .JSON.Array "posts" }}
+  <div>{{ .String "title" }}</div>
+  <div {{ .String "date" | parseTime "rfc3339" | toRelativeTime }}></div>
+{{ end }}
+```
+
+The `parseTime` function takes two arguments: the layout of the date string and the date string itself. The layout can be one of the following: "RFC3339", "RFC3339Nano", "DateTime", "DateOnly", "TimeOnly" or a custom layout in Go's [date format](https://pkg.go.dev/time#pkg-constants).
+
+Output:
+
+```html
+<div>Exploring the Depths of Quantum Computing</div>
+<div data-dynamic-relative-time="1698400800"></div>
+
+<div>A Beginner's Guide to Sustainable Living</div>
+<div data-dynamic-relative-time="1700055000"></div>
+
+<div>The Art of Baking Sourdough Bread</div>
+<div data-dynamic-relative-time="1701621922"></div>
+```
+
+You don't have to worry about the internal implementation, this will then be dynamically populated by Glance on the client side to show the correct relative time.
+
+The important thing to notice here is that the return value of `toRelativeTime` must be used as an attribute in an HTML tag, be it a `div`, `li`, `span`, etc.
+
+<hr>
+
 In some instances, you may want to know the status code of the response. This can be done using the following:
 
 ```html
@@ -273,12 +324,25 @@ The following helper functions provided by Glance are available:
 
 - `toFloat(i int) float`: Converts an integer to a float.
 - `toInt(f float) int`: Converts a float to an integer.
+- `toRelativeTime(t time.Time) template.HTMLAttr`: Converts Time to a relative time such as 2h, 1d, etc which dynamically updates. **NOTE:** the value of this function should be used as an attribute in an HTML tag, e.g. `<span {{ toRelativeTime .Time }}></span>`.
+- `parseTime(layout string, s string) time.Time`: Parses a string into time.Time. The layout must be provided in Go's [date format](https://pkg.go.dev/time#pkg-constants). You can alternatively use these values instead of the literal format: "unix", "RFC3339", "RFC3339Nano", "DateTime", "DateOnly".
+- `parseRelativeTime(layout string, s string) time.Time`: A shorthand for `{{ .String "date" | parseTime "rfc3339" | toRelativeTime }}`.
 - `add(a, b float) float`: Adds two numbers.
 - `sub(a, b float) float`: Subtracts two numbers.
 - `mul(a, b float) float`: Multiplies two numbers.
 - `div(a, b float) float`: Divides two numbers.
 - `formatApproxNumber(n int) string`: Formats a number to be more human-readable, e.g. 1000 -> 1k.
 - `formatNumber(n float|int) string`: Formats a number with commas, e.g. 1000 -> 1,000.
+- `trimPrefix(prefix string, str string) string`: Trims the prefix from a string.
+- `trimSuffix(suffix string, str string) string`: Trims the suffix from a string.
+- `trimSpace(str string) string`: Trims whitespace from a string on both ends.
+- `replaceAll(old string, new string, str string) string`: Replaces all occurrences of a string in a string.
+- `findMatch(pattern string, str string) string`: Finds the first match of a regular expression in a string.
+- `findSubmatch(pattern string, str string) string`: Finds the first submatch of a regular expression in a string.
+- `sortByString(key string, order string, arr []JSON): []JSON`: Sorts an array of JSON objects by a string key in either ascending or descending order.
+- `sortByInt(key string, order string, arr []JSON): []JSON`: Sorts an array of JSON objects by an integer key in either ascending or descending order.
+- `sortByFloat(key string, order string, arr []JSON): []JSON`: Sorts an array of JSON objects by a float key in either ascending or descending order.
+- `sortByTime(key string, layout string, order string, arr []JSON): []JSON`: Sorts an array of JSON objects by a time key in either ascending or descending order. The format must be provided in Go's [date format](https://pkg.go.dev/time#pkg-constants).
 
 The following helper functions provided by Go's `text/template` are available:
 

internal/glance/config-fields.go

@@ -219,3 +219,58 @@ func (p *proxyOptionsField) UnmarshalYAML(node *yaml.Node) error {
 
 	return nil
 }
+
+type queryParametersField map[string][]string
+
+func (q *queryParametersField) UnmarshalYAML(node *yaml.Node) error {
+	var decoded map[string]any
+
+	if err := node.Decode(&decoded); err != nil {
+		return err
+	}
+
+	*q = make(queryParametersField)
+
+	// TODO: refactor the duplication in the switch cases if any more types get added
+	for key, value := range decoded {
+		switch v := value.(type) {
+		case string:
+			(*q)[key] = []string{v}
+		case int, int8, int16, int32, int64, float32, float64:
+			(*q)[key] = []string{fmt.Sprintf("%v", v)}
+		case bool:
+			(*q)[key] = []string{fmt.Sprintf("%t", v)}
+		case []string:
+			(*q)[key] = append((*q)[key], v...)
+		case []any:
+			for _, item := range v {
+				switch item := item.(type) {
+				case string:
+					(*q)[key] = append((*q)[key], item)
+				case int, int8, int16, int32, int64, float32, float64:
+					(*q)[key] = append((*q)[key], fmt.Sprintf("%v", item))
+				case bool:
+					(*q)[key] = append((*q)[key], fmt.Sprintf("%t", item))
+				default:
+					return fmt.Errorf("invalid query parameter value type: %T", item)
+				}
+			}
+		default:
+			return fmt.Errorf("invalid query parameter value type: %T", value)
+		}
+	}
+
+	return nil
+}
+
+func (q *queryParametersField) toQueryString() string {
+	query := url.Values{}
+
+	for key, values := range *q {
+		for _, value := range values {
+			query.Add(key, value)
+		}
+	}
+
+	return query.Encode()
+}

internal/glance/diagnose.go

@@ -103,7 +103,7 @@ func runDiagnostic() {
 	fmt.Println("Glance version: " + buildVersion)
 	fmt.Println("Go version: " + runtime.Version())
 	fmt.Printf("Platform: %s / %s / %d CPUs\n", runtime.GOOS, runtime.GOARCH, runtime.NumCPU())
-	fmt.Println("In Docker container: " + boolToString(isRunningInsideDockerContainer(), "yes", "no"))
+	fmt.Println("In Docker container: " + ternary(isRunningInsideDockerContainer(), "yes", "no"))
 
 	fmt.Printf("\nChecking network connectivity, this may take up to %d seconds...\n\n", int(httpTestRequestTimeout.Seconds()))
 
@@ -129,7 +129,7 @@ func runDiagnostic() {
 
 		fmt.Printf(
 			"%s %s %s| %dms\n",
-			boolToString(step.err == nil, "✓ Can", "✗ Can't"),
+			ternary(step.err == nil, "✓ Can", "✗ Can't"),
 			step.name,
 			extraInfo,
 			step.elapsed.Milliseconds(),

internal/glance/static/main.css

@@ -552,6 +552,10 @@ kbd:active {
     z-index: 1;
 }
 
+.summary::-webkit-details-marker {
+    display: none;
+}
+
 .details[open] .summary {
     margin-bottom: .8rem;
 }
@@ -1128,7 +1132,7 @@ details[open] .summary::after {
 
 .calendar-date {
     padding: 0.4rem 0;
-    color: var(--color-text-paragraph);
+    color: var(--color-text-base);
     position: relative;
     border-radius: var(--border-radius);
     background: none;

internal/glance/templates.go

@@ -27,9 +27,7 @@ var globalTemplateFunctions = template.FuncMap{
 	"formatPrice": func(price float64) string {
 		return intl.Sprintf("%.2f", price)
 	},
-	"dynamicRelativeTimeAttrs": func(t interface{ Unix() int64 }) template.HTMLAttr {
+	"dynamicRelativeTimeAttrs": dynamicRelativeTimeAttrs,
-		return template.HTMLAttr(`data-dynamic-relative-time="` + strconv.FormatInt(t.Unix(), 10) + `"`)
-	},
 	"formatServerMegabytes": func(mb uint64) template.HTML {
 		var value string
 		var label string
@@ -81,3 +79,7 @@ func formatApproxNumber(count int) string {
 
 	return strconv.FormatFloat(float64(count)/1_000_000, 'f', 1, 64) + "m"
 }
+
+func dynamicRelativeTimeAttrs(t interface{ Unix() int64 }) template.HTMLAttr {
+	return template.HTMLAttr(`data-dynamic-relative-time="` + strconv.FormatInt(t.Unix(), 10) + `"`)
+}

internal/glance/templates/docker-containers.html

@@ -1,10 +1,10 @@
 {{ template "widget-base.html" . }}
 
 {{- define "widget-content" }}
-<div class="dynamic-columns list-gap-20 list-with-separator">
+<ul class="dynamic-columns list-gap-20 list-with-separator">
     {{- range .Containers }}
-    <div class="docker-container flex items-center gap-15">
+    <li class="docker-container flex items-center gap-15">
-        <div class="shrink-0" data-popover-type="html" data-popover-position="above" data-popover-offset="0.25" data-popover-margin="0.1rem" data-popover-max-width="400px">
+        <div class="shrink-0" data-popover-type="html" data-popover-position="above" data-popover-offset="0.25" data-popover-margin="0.1rem" data-popover-max-width="400px" aria-hidden="true">
             <img class="docker-container-icon{{ if .Icon.IsFlatIcon }} flat-icon{{ end }}" src="{{ .Icon.URL }}" alt="" loading="lazy">
             <div data-popover-html>
                 <div class="color-highlight text-truncate block">{{ .Image }}</div>
@@ -33,31 +33,33 @@
             {{- end }}
         </div>
 
-        <div class="margin-left-auto shrink-0" data-popover-type="text" data-popover-position="above" data-popover-text="{{ .State }}">
+        <div class="margin-left-auto shrink-0" data-popover-type="text" data-popover-position="above" data-popover-text="{{ .State }}" aria-label="{{ .State }}">
         {{ template "state-icon" .StateIcon }}
         </div>
-    </div>
+
+        <div class="visually-hidden" aria-label="{{ .StateText }}"></div>
+    </li>
     {{- else }}
     <div class="text-center">No containers available to show.</div>
     {{- end }}
-</div>
+</ul>
 {{- end }}
 
 {{- define "state-icon" }}
 {{- if eq . "ok" }}
-<svg class="docker-container-status-icon" fill="var(--color-positive)" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 20 20">
+<svg class="docker-container-status-icon" fill="var(--color-positive)" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 20 20" aria-hidden="true">
     <path fill-rule="evenodd" d="M10 18a8 8 0 1 0 0-16 8 8 0 0 0 0 16Zm3.857-9.809a.75.75 0 0 0-1.214-.882l-3.483 4.79-1.88-1.88a.75.75 0 1 0-1.06 1.061l2.5 2.5a.75.75 0 0 0 1.137-.089l4-5.5Z" clip-rule="evenodd" />
 </svg>
 {{- else if eq . "warn" }}
-<svg class="docker-container-status-icon" fill="var(--color-negative)" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 20 20">
+<svg class="docker-container-status-icon" fill="var(--color-negative)" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 20 20" aria-hidden="true">
     <path fill-rule="evenodd" d="M8.485 2.495c.673-1.167 2.357-1.167 3.03 0l6.28 10.875c.673 1.167-.17 2.625-1.516 2.625H3.72c-1.347 0-2.189-1.458-1.515-2.625L8.485 2.495ZM10 5a.75.75 0 0 1 .75.75v3.5a.75.75 0 0 1-1.5 0v-3.5A.75.75 0 0 1 10 5Zm0 9a1 1 0 1 0 0-2 1 1 0 0 0 0 2Z" clip-rule="evenodd" />
 </svg>
 {{- else if eq . "paused" }}
-<svg class="docker-container-status-icon" fill="var(--color-text-base)" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 20 20">
+<svg class="docker-container-status-icon" fill="var(--color-text-base)" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 20 20" aria-hidden="true">
     <path fill-rule="evenodd" d="M2 10a8 8 0 1 1 16 0 8 8 0 0 1-16 0Zm5-2.25A.75.75 0 0 1 7.75 7h.5a.75.75 0 0 1 .75.75v4.5a.75.75 0 0 1-.75.75h-.5a.75.75 0 0 1-.75-.75v-4.5Zm4 0a.75.75 0 0 1 .75-.75h.5a.75.75 0 0 1 .75.75v4.5a.75.75 0 0 1-.75.75h-.5a.75.75 0 0 1-.75-.75v-4.5Z" clip-rule="evenodd" />
 </svg>
 {{- else }}
-<svg class="docker-container-status-icon" fill="var(--color-text-base)" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 20 20">
+<svg class="docker-container-status-icon" fill="var(--color-text-base)" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 20 20" aria-hidden="true">
     <path fill-rule="evenodd" d="M18 10a8 8 0 1 1-16 0 8 8 0 0 1 16 0ZM8.94 6.94a.75.75 0 1 1-1.061-1.061 3 3 0 1 1 2.871 5.026v.345a.75.75 0 0 1-1.5 0v-.5c0-.72.57-1.172 1.081-1.287A1.5 1.5 0 1 0 8.94 6.94ZM10 15a1 1 0 1 0 0-2 1 1 0 0 0 0 2Z" clip-rule="evenodd" />
 </svg>
 {{- end }}

internal/glance/templates/videos-vertical-list.html

@@ -6,7 +6,7 @@
     <li class="flex thumbnail-parent gap-10 items-center">
         <img class="video-horizontal-list-thumbnail thumbnail" loading="lazy" src="{{ .ThumbnailUrl }}" alt="">
         <div class="min-width-0">
-            <a class="block text-truncate color-primary-if-not-visited" href="{{ .Url }}">{{ .Title }}</a>
+            <a class="block text-truncate color-primary-if-not-visited" href="{{ .Url }}" target="_blank" rel="noreferrer">{{ .Title }}</a>
             <ul class="list-horizontal-text flex-nowrap">
                 <li class="shrink-0" {{ dynamicRelativeTimeAttrs .TimePosted }}></li>
                 <li class="min-width-0">

internal/glance/utils.go

@@ -119,14 +119,6 @@ func parseRFC3339Time(t string) time.Time {
 	return parsed
 }
 
-func boolToString(b bool, trueValue, falseValue string) string {
-	if b {
-		return trueValue
-	}
-
-	return falseValue
-}
-
 func normalizeVersionFormat(version string) string {
 	version = strings.ToLower(strings.TrimSpace(version))
 

internal/glance/widget-custom-api.go

@@ -3,6 +3,7 @@ package glance
 import (
 	"bytes"
 	"context"
+	"encoding/json"
 	"errors"
 	"fmt"
 	"html/template"
@@ -10,6 +11,11 @@ import (
 	"log/slog"
 	"math"
 	"net/http"
+	"regexp"
+	"sort"
+	"strconv"
+	"strings"
+	"sync"
 	"time"
 
 	"github.com/tidwall/gjson"
@@ -17,22 +23,40 @@ import (
 
 var customAPIWidgetTemplate = mustParseTemplate("custom-api.html", "widget-base.html")
 
+// Needs to be exported for the YAML unmarshaler to work
+type CustomAPIRequest struct {
+	URL           string               `yaml:"url"`
+	AllowInsecure bool                 `yaml:"allow-insecure"`
+	Headers       map[string]string    `yaml:"headers"`
+	Parameters    queryParametersField `yaml:"parameters"`
+	Method        string               `yaml:"method"`
+	BodyType      string               `yaml:"body-type"`
+	Body          any                  `yaml:"body"`
+	bodyReader    io.ReadSeeker        `yaml:"-"`
+	httpRequest   *http.Request        `yaml:"-"`
+}
+
 type customAPIWidget struct {
-	widgetBase       `yaml:",inline"`
+	widgetBase        `yaml:",inline"`
-	URL              string             `yaml:"url"`
+	*CustomAPIRequest `yaml:",inline"`             // the primary request
-	Template         string             `yaml:"template"`
+	Subrequests       map[string]*CustomAPIRequest `yaml:"subrequests"`
-	Frameless        bool               `yaml:"frameless"`
+	Template          string                       `yaml:"template"`
-	Headers          map[string]string  `yaml:"headers"`
+	Frameless         bool                         `yaml:"frameless"`
-	APIRequest       *http.Request      `yaml:"-"`
+	compiledTemplate  *template.Template           `yaml:"-"`
-	compiledTemplate *template.Template `yaml:"-"`
+	CompiledHTML      template.HTML                `yaml:"-"`
-	CompiledHTML     template.HTML      `yaml:"-"`
 }
 
 func (widget *customAPIWidget) initialize() error {
 	widget.withTitle("Custom API").withCacheDuration(1 * time.Hour)
 
-	if widget.URL == "" {
+	if err := widget.CustomAPIRequest.initialize(); err != nil {
-		return errors.New("URL is required")
+		return fmt.Errorf("initializing primary request: %v", err)
+	}
+
+	for key := range widget.Subrequests {
+		if err := widget.Subrequests[key].initialize(); err != nil {
+			return fmt.Errorf("initializing subrequest %q: %v", key, err)
+		}
 	}
 
 	if widget.Template == "" {
@@ -46,22 +70,11 @@ func (widget *customAPIWidget) initialize() error {
 
 	widget.compiledTemplate = compiledTemplate
 
-	req, err := http.NewRequest(http.MethodGet, widget.URL, nil)
-	if err != nil {
-		return err
-	}
-
-	for key, value := range widget.Headers {
-		req.Header.Add(key, value)
-	}
-
-	widget.APIRequest = req
-
 	return nil
 }
 
 func (widget *customAPIWidget) update(ctx context.Context) {
-	compiledHTML, err := fetchAndParseCustomAPI(widget.APIRequest, widget.compiledTemplate)
+	compiledHTML, err := fetchAndParseCustomAPI(widget.CustomAPIRequest, widget.Subrequests, widget.compiledTemplate)
 	if !widget.canContinueUpdateAfterHandlingErr(err) {
 		return
 	}
@@ -73,39 +86,196 @@ func (widget *customAPIWidget) Render() template.HTML {
 	return widget.renderTemplate(widget, customAPIWidgetTemplate)
 }
 
-func fetchAndParseCustomAPI(req *http.Request, tmpl *template.Template) (template.HTML, error) {
+func (req *CustomAPIRequest) initialize() error {
-	emptyBody := template.HTML("")
+	if req.URL == "" {
+		return errors.New("URL is required")
+	}
 
-	resp, err := defaultHTTPClient.Do(req)
+	if req.Body != nil {
+		if req.Method == "" {
+			req.Method = http.MethodPost
+		}
+
+		if req.BodyType == "" {
+			req.BodyType = "json"
+		}
+
+		if req.BodyType != "json" && req.BodyType != "string" {
+			return errors.New("invalid body type, must be either 'json' or 'string'")
+		}
+
+		switch req.BodyType {
+		case "json":
+			encoded, err := json.Marshal(req.Body)
+			if err != nil {
+				return fmt.Errorf("marshaling body: %v", err)
+			}
+
+			req.bodyReader = bytes.NewReader(encoded)
+		case "string":
+			bodyAsString, ok := req.Body.(string)
+			if !ok {
+				return errors.New("body must be a string when body-type is 'string'")
+			}
+
+			req.bodyReader = strings.NewReader(bodyAsString)
+		}
+
+	} else if req.Method == "" {
+		req.Method = http.MethodGet
+	}
+
+	httpReq, err := http.NewRequest(strings.ToUpper(req.Method), req.URL, req.bodyReader)
 	if err != nil {
-		return emptyBody, err
+		return err
+	}
+
+	if len(req.Parameters) > 0 {
+		httpReq.URL.RawQuery = req.Parameters.toQueryString()
+	}
+
+	if req.BodyType == "json" {
+		httpReq.Header.Set("Content-Type", "application/json")
+	}
+
+	for key, value := range req.Headers {
+		httpReq.Header.Add(key, value)
+	}
+
+	req.httpRequest = httpReq
+
+	return nil
+}
+
+type customAPIResponseData struct {
+	JSON     decoratedGJSONResult
+	Response *http.Response
+}
+
+type customAPITemplateData struct {
+	*customAPIResponseData
+	subrequests map[string]*customAPIResponseData
+}
+
+func (data *customAPITemplateData) Subrequest(key string) *customAPIResponseData {
+	req, exists := data.subrequests[key]
+	if !exists {
+		// We have to panic here since there's nothing sensible we can return and the
+		// lack of an error would cause requested data to return zero values which
+		// would be confusing from the user's perspective. Go's template module
+		// handles recovering from panics and will return the panic message as an
+		// error during template execution.
+		panic(fmt.Sprintf("subrequest with key %q has not been defined", key))
+	}
+
+	return req
+}
+
+func fetchCustomAPIRequest(ctx context.Context, req *CustomAPIRequest) (*customAPIResponseData, error) {
+	if req.bodyReader != nil {
+		req.bodyReader.Seek(0, io.SeekStart)
+	}
+
+	client := ternary(req.AllowInsecure, defaultInsecureHTTPClient, defaultHTTPClient)
+	resp, err := client.Do(req.httpRequest.WithContext(ctx))
+	if err != nil {
+		return nil, err
 	}
 	defer resp.Body.Close()
 
 	bodyBytes, err := io.ReadAll(resp.Body)
 	if err != nil {
-		return emptyBody, err
+		return nil, err
 	}
 
-	body := string(bodyBytes)
+	body := strings.TrimSpace(string(bodyBytes))
 
-	if !gjson.Valid(body) {
+	if body != "" && !gjson.Valid(body) {
 		truncatedBody, isTruncated := limitStringLength(body, 100)
 		if isTruncated {
 			truncatedBody += "... <truncated>"
 		}
 
-		slog.Error("Invalid response JSON in custom API widget", "url", req.URL.String(), "body", truncatedBody)
+		slog.Error("Invalid response JSON in custom API widget", "url", req.httpRequest.URL.String(), "body", truncatedBody)
-		return emptyBody, errors.New("invalid response JSON")
+		return nil, errors.New("invalid response JSON")
 	}
 
-	var templateBuffer bytes.Buffer
+	data := &customAPIResponseData{
-
-	data := customAPITemplateData{
 		JSON:     decoratedGJSONResult{gjson.Parse(body)},
 		Response: resp,
 	}
 
+	return data, nil
+}
+
+func fetchAndParseCustomAPI(
+	primaryReq *CustomAPIRequest,
+	subReqs map[string]*CustomAPIRequest,
+	tmpl *template.Template,
+) (template.HTML, error) {
+	var primaryData *customAPIResponseData
+	subData := make(map[string]*customAPIResponseData, len(subReqs))
+	var err error
+
+	if len(subReqs) == 0 {
+		// If there are no subrequests, we can fetch the primary request in a much simpler way
+		primaryData, err = fetchCustomAPIRequest(context.Background(), primaryReq)
+	} else {
+		// If there are subrequests, we need to fetch them concurrently
+		// and cancel all requests if any of them fail. There's probably
+		// a more elegant way to do this, but this works for now.
+		ctx, cancel := context.WithCancel(context.Background())
+		defer cancel()
+
+		var wg sync.WaitGroup
+		var mu sync.Mutex // protects subData and err
+
+		wg.Add(1)
+		go func() {
+			defer wg.Done()
+			var localErr error
+			primaryData, localErr = fetchCustomAPIRequest(ctx, primaryReq)
+			mu.Lock()
+			if localErr != nil && err == nil {
+				err = localErr
+				cancel()
+			}
+			mu.Unlock()
+		}()
+
+		for key, req := range subReqs {
+			wg.Add(1)
+			go func() {
+				defer wg.Done()
+				var localErr error
+				var data *customAPIResponseData
+				data, localErr = fetchCustomAPIRequest(ctx, req)
+				mu.Lock()
+				if localErr == nil {
+					subData[key] = data
+				} else if err == nil {
+					err = localErr
+					cancel()
+				}
+				mu.Unlock()
+			}()
+		}
+
+		wg.Wait()
+	}
+
+	emptyBody := template.HTML("")
+
+	if err != nil {
+		return emptyBody, err
+	}
+
+	data := customAPITemplateData{
+		customAPIResponseData: primaryData,
+		subrequests:           subData,
+	}
+
+	var templateBuffer bytes.Buffer
 	err = tmpl.Execute(&templateBuffer, &data)
 	if err != nil {
 		return emptyBody, err
@@ -118,11 +288,6 @@ type decoratedGJSONResult struct {
 	gjson.Result
 }
 
-type customAPITemplateData struct {
-	JSON     decoratedGJSONResult
-	Response *http.Response
-}
-
 func gJsonResultArrayToDecoratedResultArray(results []gjson.Result) []decoratedGJSONResult {
 	decoratedResults := make([]decoratedGJSONResult, len(results))
 
@@ -153,12 +318,12 @@ func (r *decoratedGJSONResult) String(key string) string {
 	return r.Get(key).String()
 }
 
-func (r *decoratedGJSONResult) Int(key string) int64 {
+func (r *decoratedGJSONResult) Int(key string) int {
 	if key == "" {
-		return r.Result.Int()
+		return int(r.Result.Int())
 	}
 
-	return r.Get(key).Int()
+	return int(r.Get(key).Int())
 }
 
 func (r *decoratedGJSONResult) Float(key string) float64 {
@@ -178,12 +343,28 @@ func (r *decoratedGJSONResult) Bool(key string) bool {
 }
 
 var customAPITemplateFuncs = func() template.FuncMap {
+	var regexpCacheMu sync.Mutex
+	var regexpCache = make(map[string]*regexp.Regexp)
+
+	getCachedRegexp := func(pattern string) *regexp.Regexp {
+		regexpCacheMu.Lock()
+		defer regexpCacheMu.Unlock()
+
+		regex, exists := regexpCache[pattern]
+		if !exists {
+			regex = regexp.MustCompile(pattern)
+			regexpCache[pattern] = regex
+		}
+
+		return regex
+	}
+
 	funcs := template.FuncMap{
-		"toFloat": func(a int64) float64 {
+		"toFloat": func(a int) float64 {
 			return float64(a)
 		},
-		"toInt": func(a float64) int64 {
+		"toInt": func(a float64) int {
-			return int64(a)
+			return int(a)
 		},
 		"add": func(a, b float64) float64 {
 			return a + b
@@ -201,6 +382,89 @@ var customAPITemplateFuncs = func() template.FuncMap {
 
 			return a / b
 		},
+		"parseTime":      customAPIFuncParseTime,
+		"toRelativeTime": dynamicRelativeTimeAttrs,
+		"parseRelativeTime": func(layout, value string) template.HTMLAttr {
+			// Shorthand to do both of the above with a single function call
+			return dynamicRelativeTimeAttrs(customAPIFuncParseTime(layout, value))
+		},
+		// The reason we flip the parameter order is so that you can chain multiple calls together like this:
+		// {{ .JSON.String "foo" | trimPrefix "bar" | doSomethingElse }}
+		// instead of doing this:
+		// {{ trimPrefix (.JSON.String "foo") "bar" | doSomethingElse }}
+		// since the piped value gets passed as the last argument to the function.
+		"trimPrefix": func(prefix, s string) string {
+			return strings.TrimPrefix(s, prefix)
+		},
+		"trimSuffix": func(suffix, s string) string {
+			return strings.TrimSuffix(s, suffix)
+		},
+		"trimSpace": strings.TrimSpace,
+		"replaceAll": func(old, new, s string) string {
+			return strings.ReplaceAll(s, old, new)
+		},
+		"findMatch": func(pattern, s string) string {
+			if s == "" {
+				return ""
+			}
+
+			return getCachedRegexp(pattern).FindString(s)
+		},
+		"findSubmatch": func(pattern, s string) string {
+			if s == "" {
+				return ""
+			}
+
+			regex := getCachedRegexp(pattern)
+			return itemAtIndexOrDefault(regex.FindStringSubmatch(s), 1, "")
+		},
+		"sortByString": func(key, order string, results []decoratedGJSONResult) []decoratedGJSONResult {
+			sort.Slice(results, func(a, b int) bool {
+				if order == "asc" {
+					return results[a].String(key) < results[b].String(key)
+				}
+
+				return results[a].String(key) > results[b].String(key)
+			})
+
+			return results
+		},
+		"sortByInt": func(key, order string, results []decoratedGJSONResult) []decoratedGJSONResult {
+			sort.Slice(results, func(a, b int) bool {
+				if order == "asc" {
+					return results[a].Int(key) < results[b].Int(key)
+				}
+
+				return results[a].Int(key) > results[b].Int(key)
+			})
+
+			return results
+		},
+		"sortByFloat": func(key, order string, results []decoratedGJSONResult) []decoratedGJSONResult {
+			sort.Slice(results, func(a, b int) bool {
+				if order == "asc" {
+					return results[a].Float(key) < results[b].Float(key)
+				}
+
+				return results[a].Float(key) > results[b].Float(key)
+			})
+
+			return results
+		},
+		"sortByTime": func(key, layout, order string, results []decoratedGJSONResult) []decoratedGJSONResult {
+			sort.Slice(results, func(a, b int) bool {
+				timeA := customAPIFuncParseTime(layout, results[a].String(key))
+				timeB := customAPIFuncParseTime(layout, results[b].String(key))
+
+				if order == "asc" {
+					return timeA.Before(timeB)
+				}
+
+				return timeA.After(timeB)
+			})
+
+			return results
+		},
 	}
 
 	for key, value := range globalTemplateFunctions {
@@ -211,3 +475,30 @@ var customAPITemplateFuncs = func() template.FuncMap {
 
 	return funcs
 }()
+
+func customAPIFuncParseTime(layout, value string) time.Time {
+	switch strings.ToLower(layout) {
+	case "unix":
+		asInt, err := strconv.ParseInt(value, 10, 64)
+		if err != nil {
+			return time.Unix(0, 0)
+		}
+
+		return time.Unix(asInt, 0)
+	case "rfc3339":
+		layout = time.RFC3339
+	case "rfc3339nano":
+		layout = time.RFC3339Nano
+	case "datetime":
+		layout = time.DateTime
+	case "dateonly":
+		layout = time.DateOnly
+	}
+
+	parsed, err := time.Parse(layout, value)
+	if err != nil {
+		return time.Unix(0, 0)
+	}
+
+	return parsed
+}

internal/glance/widget-dns-stats.go

@@ -644,7 +644,10 @@ func fetchPiholeSessionID(instanceURL string, client *http.Client, password stri
 	}
 
 	if jsonResponse.Session.SID == "" {
-		return "", errors.New("authentication response returned empty session ID")
+		return "", fmt.Errorf(
+			"authentication response returned empty session ID, status code %d, message '%s'",
+			response.StatusCode, jsonResponse.Session.Message,
+		)
 	}
 
 	return jsonResponse.Session.SID, nil

internal/glance/widget-extension.go

@@ -19,12 +19,13 @@ const extensionWidgetDefaultTitle = "Extension"
 
 type extensionWidget struct {
 	widgetBase          `yaml:",inline"`
-	URL                 string            `yaml:"url"`
+	URL                 string               `yaml:"url"`
-	FallbackContentType string            `yaml:"fallback-content-type"`
+	FallbackContentType string               `yaml:"fallback-content-type"`
-	Parameters          map[string]string `yaml:"parameters"`
+	Parameters          queryParametersField `yaml:"parameters"`
-	AllowHtml           bool              `yaml:"allow-potentially-dangerous-html"`
+	Headers             map[string]string    `yaml:"headers"`
-	Extension           extension         `yaml:"-"`
+	AllowHtml           bool                 `yaml:"allow-potentially-dangerous-html"`
-	cachedHTML          template.HTML     `yaml:"-"`
+	Extension           extension            `yaml:"-"`
+	cachedHTML          template.HTML        `yaml:"-"`
 }
 
 func (widget *extensionWidget) initialize() error {
@@ -46,6 +47,7 @@ func (widget *extensionWidget) update(ctx context.Context) {
 		URL:                 widget.URL,
 		FallbackContentType: widget.FallbackContentType,
 		Parameters:          widget.Parameters,
+		Headers:             widget.Headers,
 		AllowHtml:           widget.AllowHtml,
 	})
 
@@ -82,10 +84,11 @@ const (
 )
 
 type extensionRequestOptions struct {
-	URL                 string            `yaml:"url"`
+	URL                 string               `yaml:"url"`
-	FallbackContentType string            `yaml:"fallback-content-type"`
+	FallbackContentType string               `yaml:"fallback-content-type"`
-	Parameters          map[string]string `yaml:"parameters"`
+	Parameters          queryParametersField `yaml:"parameters"`
-	AllowHtml           bool              `yaml:"allow-potentially-dangerous-html"`
+	Headers             map[string]string    `yaml:"headers"`
+	AllowHtml           bool                 `yaml:"allow-potentially-dangerous-html"`
 }
 
 type extension struct {
@@ -109,14 +112,13 @@ func convertExtensionContent(options extensionRequestOptions, content []byte, co
 
 func fetchExtension(options extensionRequestOptions) (extension, error) {
 	request, _ := http.NewRequest("GET", options.URL, nil)
-
+	if len(options.Parameters) > 0 {
-	query := url.Values{}
+		request.URL.RawQuery = options.Parameters.toQueryString()
-
-	for key, value := range options.Parameters {
-		query.Set(key, value)
 	}
 
-	request.URL.RawQuery = query.Encode()
+	for key, value := range options.Headers {
+		request.Header.Add(key, value)
+	}
 
 	response, err := http.DefaultClient.Do(request)
 	if err != nil {

internal/glance/widget-videos.go

@@ -56,7 +56,7 @@ func (widget *videosWidget) initialize() error {
 		widget.Channels = append(widget.Channels, make([]string, len(widget.Playlists))...)
 
 		for i := range widget.Playlists {
-			widget.Channels[initialLen+i] = "playlist:" + widget.Playlists[i]
+			widget.Channels[initialLen+i] = videosWidgetPlaylistPrefix + widget.Playlists[i]
 		}
 	}