├── .bra.toml
├── .codespell_ignore
├── .config
    ├── .eslintrc
    ├── .prettierrc.js
    ├── Dockerfile
    ├── README.md
    ├── jest-setup.js
    ├── jest.config.js
    ├── jest
    │   ├── mocks
    │   │   └── react-inlinesvg.tsx
    │   └── utils.js
    ├── tsconfig.json
    └── webpack
    │   ├── constants.ts
    │   ├── utils.ts
    │   └── webpack.config.ts
├── .eslintrc
├── .gitattributes
├── .gitignore
├── .nvmrc
├── .prettierignore
├── .prettierrc.js
├── CHANGELOG.md
├── LICENSE
├── Magefile.go
├── Makefile
├── README.md
├── cspell.config.json
├── debug-backend.sh
├── devenv
    ├── docker-compose.yml
    └── grafana.ini
├── docker-compose.yaml
├── docs
    ├── configuration.md
    └── img
    │   ├── config_1.png
    │   ├── config_2.png
    │   └── config_3.png
├── go.mod
├── go.sum
├── jest-setup.js
├── jest.config.js
├── package.json
├── pkg
    ├── datasource
    │   ├── datasource.go
    │   ├── dscache.go
    │   ├── models.go
    │   ├── prefetcher.go
    │   └── resource_handler.go
    ├── grafanaclient
    │   └── client.go
    └── plugin.go
├── setup_tests.ts
├── src
    ├── components
    │   ├── AthleteLabel.tsx
    │   ├── ConfigEditor.tsx
    │   ├── QueryEditor.tsx
    │   └── VariableQueryEditor.tsx
    ├── dashboards
    │   ├── strava_activity_analysis.json
    │   ├── strava_activity_overview.json
    │   ├── strava_athlete_dashboard.json
    │   ├── strava_datasource.json
    │   └── strava_segment_overview.json
    ├── datasource.test.ts
    ├── datasource.ts
    ├── img
    │   ├── btn_strava_connectwith_orange.svg
    │   └── strava_logo.svg
    ├── module.tsx
    ├── plugin.json
    ├── polyline.ts
    ├── responseHandler.ts
    ├── stravaApi.ts
    ├── types.ts
    └── utils.ts
├── tsconfig.jest.json
├── tsconfig.json
└── yarn.lock


/.bra.toml:
--------------------------------------------------------------------------------
 1 | [run]
 2 | init_cmds = [
 3 | 	["make", "build-backend"],
 4 | 	["pkill", "strava-plugin"]
 5 | ]									# Commands run in start
 6 | watch_all = true					# Watch all sub-directories
 7 | watch_dirs = ["pkg"]						# Directories to watch
 8 | watch_exts = [".go"]				# Extensions to watch
 9 | ignore = [".git", "node_modules"] 	# Directories to exclude from watching
10 | ignore_files = []					# Regexps for ignoring specific notifies
11 | build_delay = 1500					# Minimal interval to Trigger build event
12 | interrupt_timout = 15				# Time to wait until force kill
13 | graceful_kill = false				# Wait for exit and before directly kill
14 | cmds = [
15 | 	["make", "build-backend"],
16 | 	["pkill", "strava-plugin"]
17 | ]									# Commands to run
18 | 
19 | [sync]
20 | listen_addr = ":5050"
21 | remote_addr = ":5050"
22 | 


--------------------------------------------------------------------------------
/.codespell_ignore:
--------------------------------------------------------------------------------
1 | ro
2 | 


--------------------------------------------------------------------------------
/.config/.eslintrc:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * ⚠️⚠️⚠️ THIS FILE WAS SCAFFOLDED BY `@grafana/create-plugin`. DO NOT EDIT THIS FILE DIRECTLY. ⚠️⚠️⚠️
 3 |  *
 4 |  * In order to extend the configuration follow the steps in
 5 |  * https://grafana.github.io/plugin-tools/docs/advanced-configuration#extending-the-eslint-config
 6 |  */
 7 |  {
 8 |   "extends": ["@grafana/eslint-config"],
 9 |   "root": true,
10 |   "rules": {
11 |     "react/prop-types": "off"
12 |   }
13 | }
14 | 


--------------------------------------------------------------------------------
/.config/.prettierrc.js:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * ⚠️⚠️⚠️ THIS FILE WAS SCAFFOLDED BY `@grafana/create-plugin`. DO NOT EDIT THIS FILE DIRECTLY. ⚠️⚠️⚠️
 3 |  *
 4 |  * In order to extend the configuration follow the steps in .config/README.md
 5 |  */
 6 | 
 7 | module.exports = {
 8 |   "endOfLine": "auto",
 9 |   "printWidth": 120,
10 |   "trailingComma": "es5",
11 |   "semi": true,
12 |   "jsxSingleQuote": false,
13 |   "singleQuote": true,
14 |   "useTabs": false,
15 |   "tabWidth": 2
16 | };


--------------------------------------------------------------------------------
/.config/Dockerfile:
--------------------------------------------------------------------------------
 1 | ARG grafana_version=latest
 2 | ARG grafana_image=grafana-enterprise
 3 | 
 4 | FROM grafana/${grafana_image}:${grafana_version}
 5 | 
 6 | # Make it as simple as possible to access the grafana instance for development purposes
 7 | # Do NOT enable these settings in a public facing / production grafana instance
 8 | ENV GF_AUTH_ANONYMOUS_ORG_ROLE "Admin"
 9 | ENV GF_AUTH_ANONYMOUS_ENABLED "true"
10 | ENV GF_AUTH_BASIC_ENABLED "false"
11 | # Set development mode so plugins can be loaded without the need to sign
12 | ENV GF_DEFAULT_APP_MODE "development"
13 | 
14 | # Inject livereload script into grafana index.html
15 | USER root
16 | RUN sed -i 's/<\/body><\/html>/<script src=\"http:\/\/localhost:35729\/livereload.js\"><\/script><\/body><\/html>/g' /usr/share/grafana/public/views/index.html


--------------------------------------------------------------------------------
/.config/README.md:
--------------------------------------------------------------------------------
  1 | # Default build configuration by Grafana
  2 | 
  3 | **This is an auto-generated directory and is not intended to be changed! ⚠️**
  4 | 
  5 | The `.config/` directory holds basic configuration for the different tools
  6 | that are used to develop, test and build the project. In order to make it updates easier we ask you to
  7 | not edit files in this folder to extend configuration.
  8 | 
  9 | ## How to extend the basic configs?
 10 | 
 11 | Bear in mind that you are doing it at your own risk, and that extending any of the basic configuration can lead
 12 | to issues around working with the project.
 13 | 
 14 | ### Extending the ESLint config
 15 | 
 16 | Edit the `.eslintrc` file in the project root in order to extend the ESLint configuration.
 17 | 
 18 | **Example:**
 19 | 
 20 | ```json
 21 | {
 22 |   "extends": "./.config/.eslintrc",
 23 |   "rules": {
 24 |     "react/prop-types": "off"
 25 |   }
 26 | }
 27 | ```
 28 | 
 29 | ---
 30 | 
 31 | ### Extending the Prettier config
 32 | 
 33 | Edit the `.prettierrc.js` file in the project root in order to extend the Prettier configuration.
 34 | 
 35 | **Example:**
 36 | 
 37 | ```javascript
 38 | module.exports = {
 39 |   // Prettier configuration provided by Grafana scaffolding
 40 |   ...require('./.config/.prettierrc.js'),
 41 | 
 42 |   semi: false,
 43 | };
 44 | ```
 45 | 
 46 | ---
 47 | 
 48 | ### Extending the Jest config
 49 | 
 50 | There are two configuration in the project root that belong to Jest: `jest-setup.js` and `jest.config.js`.
 51 | 
 52 | **`jest-setup.js`:** A file that is run before each test file in the suite is executed. We are using it to
 53 | set up the Jest DOM for the testing library and to apply some polyfills. ([link to Jest docs](https://jestjs.io/docs/configuration#setupfilesafterenv-array))
 54 | 
 55 | **`jest.config.js`:** The main Jest configuration file that extends the Grafana recommended setup. ([link to Jest docs](https://jestjs.io/docs/configuration))
 56 | 
 57 | #### ESM errors with Jest
 58 | 
 59 | A common issue found with the current jest config involves importing an npm package which only offers an ESM build. These packages cause jest to error with `SyntaxError: Cannot use import statement outside a module`. To work around this we provide a list of known packages to pass to the `[transformIgnorePatterns](https://jestjs.io/docs/configuration#transformignorepatterns-arraystring)` jest configuration property. If need be this can be extended in the following way:
 60 | 
 61 | ```javascript
 62 | process.env.TZ = 'UTC';
 63 | const { grafanaESModules, nodeModulesToTransform } = require('./config/jest/utils');
 64 | 
 65 | module.exports = {
 66 |   // Jest configuration provided by Grafana
 67 |   ...require('./.config/jest.config'),
 68 |   // Inform jest to only transform specific node_module packages.
 69 |   transformIgnorePatterns: [nodeModulesToTransform([...grafanaESModules, 'packageName'])],
 70 | };
 71 | ```
 72 | 
 73 | ---
 74 | 
 75 | ### Extending the TypeScript config
 76 | 
 77 | Edit the `tsconfig.json` file in the project root in order to extend the TypeScript configuration.
 78 | 
 79 | **Example:**
 80 | 
 81 | ```json
 82 | {
 83 |   "extends": "./.config/tsconfig.json",
 84 |   "compilerOptions": {
 85 |     "preserveConstEnums": true
 86 |   }
 87 | }
 88 | ```
 89 | 
 90 | ---
 91 | 
 92 | ### Extending the Webpack config
 93 | 
 94 | Follow these steps to extend the basic Webpack configuration that lives under `.config/`:
 95 | 
 96 | #### 1. Create a new Webpack configuration file
 97 | 
 98 | Create a new config file that is going to extend the basic one provided by Grafana.
 99 | It can live in the project root, e.g. `webpack.config.ts`.
100 | 
101 | #### 2. Merge the basic config provided by Grafana and your custom setup
102 | 
103 | We are going to use [`webpack-merge`](https://github.com/survivejs/webpack-merge) for this.
104 | 
105 | ```typescript
106 | // webpack.config.ts
107 | import type { Configuration } from 'webpack';
108 | import { merge } from 'webpack-merge';
109 | import grafanaConfig from './.config/webpack/webpack.config';
110 | 
111 | const config = async (env): Promise<Configuration> => {
112 |   const baseConfig = await grafanaConfig(env);
113 | 
114 |   return merge(baseConfig, {
115 |     // Add custom config here...
116 |     output: {
117 |       asyncChunks: true,
118 |     },
119 |   });
120 | };
121 | 
122 | export default config;
123 | ```
124 | 
125 | #### 3. Update the `package.json` to use the new Webpack config
126 | 
127 | We need to update the `scripts` in the `package.json` to use the extended Webpack configuration.
128 | 
129 | **Update for `build`:**
130 | 
131 | ```diff
132 | -"build": "webpack -c ./.config/webpack/webpack.config.ts --env production",
133 | +"build": "webpack -c ./webpack.config.ts --env production",
134 | ```
135 | 
136 | **Update for `dev`:**
137 | 
138 | ```diff
139 | -"dev": "webpack -w -c ./.config/webpack/webpack.config.ts --env development",
140 | +"dev": "webpack -w -c ./webpack.config.ts --env development",
141 | ```
142 | 
143 | ### Configure grafana image to use when running docker
144 | 
145 | By default `grafana-enterprise` will be used as the docker image for all docker related commands. If you want to override this behaviour simply alter the `docker-compose.yaml` by adding the following build arg `grafana_image`. 
146 | 
147 | **Example:**
148 | 
149 | ```yaml
150 | version: '3.7'
151 | 
152 | services:
153 |   grafana:
154 |     container_name: 'myorg-basic-app'
155 |     build:
156 |       context: ./.config
157 |       args:
158 |         grafana_version: ${GRAFANA_VERSION:-9.1.2}
159 |         grafana_image: ${GRAFANA_IMAGE:-grafana}
160 | ```
161 | 
162 | In this example we are assigning the environment variable `GRAFANA_IMAGE` to the build arg `grafana_image` with a default value of `grafana`. This will give you the possibility to set the value while running the docker-compose commands which might be convinent in some scenarios.
163 | 
164 | ---
165 | 


--------------------------------------------------------------------------------
/.config/jest-setup.js:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * ⚠️⚠️⚠️ THIS FILE WAS SCAFFOLDED BY `@grafana/create-plugin`. DO NOT EDIT THIS FILE DIRECTLY. ⚠️⚠️⚠️
 3 |  *
 4 |  * In order to extend the configuration follow the steps in
 5 |  * https://grafana.github.io/plugin-tools/docs/advanced-configuration#extending-the-jest-config
 6 |  */
 7 | 
 8 | import '@testing-library/jest-dom';
 9 | 
10 | // https://jestjs.io/docs/manual-mocks#mocking-methods-which-are-not-implemented-in-jsdom
11 | Object.defineProperty(global, 'matchMedia', {
12 |   writable: true,
13 |   value: jest.fn().mockImplementation((query) => ({
14 |     matches: false,
15 |     media: query,
16 |     onchange: null,
17 |     addListener: jest.fn(), // deprecated
18 |     removeListener: jest.fn(), // deprecated
19 |     addEventListener: jest.fn(),
20 |     removeEventListener: jest.fn(),
21 |     dispatchEvent: jest.fn(),
22 |   })),
23 | });
24 | 
25 | HTMLCanvasElement.prototype.getContext = () => {};
26 | 


--------------------------------------------------------------------------------
/.config/jest.config.js:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * ⚠️⚠️⚠️ THIS FILE WAS SCAFFOLDED BY `@grafana/create-plugin`. DO NOT EDIT THIS FILE DIRECTLY. ⚠️⚠️⚠️
 3 |  *
 4 |  * In order to extend the configuration follow the steps in
 5 |  * https://grafana.github.io/plugin-tools/docs/advanced-configuration#extending-the-jest-config
 6 |  */
 7 | 
 8 | const path = require('path');
 9 | const { grafanaESModules, nodeModulesToTransform } = require('./jest/utils');
10 | 
11 | module.exports = {
12 |   moduleNameMapper: {
13 |     '\\.(css|scss|sass)$': 'identity-obj-proxy',
14 |     'react-inlinesvg': path.resolve(__dirname, 'jest', 'mocks', 'react-inlinesvg.tsx'),
15 |   },
16 |   modulePaths: ['<rootDir>/src'],
17 |   setupFilesAfterEnv: ['<rootDir>/jest-setup.js'],
18 |   testEnvironment: 'jest-environment-jsdom',
19 |   testMatch: [
20 |     '<rootDir>/src/**/__tests__/**/*.{js,jsx,ts,tsx}',
21 |     '<rootDir>/src/**/*.{spec,test,jest}.{js,jsx,ts,tsx}',
22 |     '<rootDir>/src/**/*.{spec,test,jest}.{js,jsx,ts,tsx}',
23 |   ],
24 |   transform: {
25 |     '^.+\\.(t|j)sx?$': [
26 |       '@swc/jest',
27 |       {
28 |         sourceMaps: 'inline',
29 |         jsc: {
30 |           parser: {
31 |             syntax: 'typescript',
32 |             tsx: true,
33 |             decorators: false,
34 |             dynamicImport: true,
35 |           },
36 |         },
37 |       },
38 |     ],
39 |   },
40 |   // Jest will throw `Cannot use import statement outside module` if it tries to load an
41 |   // ES module without it being transformed first. ./config/README.md#esm-errors-with-jest
42 |   transformIgnorePatterns: [nodeModulesToTransform(grafanaESModules)],
43 | };
44 | 


--------------------------------------------------------------------------------
/.config/jest/mocks/react-inlinesvg.tsx:
--------------------------------------------------------------------------------
 1 | // Due to the grafana/ui Icon component making fetch requests to
 2 | // `/public/img/icon/<icon_name>.svg` we need to mock react-inlinesvg to prevent
 3 | // the failed fetch requests from displaying errors in console.
 4 | 
 5 | import React from 'react';
 6 | 
 7 | type Callback = (...args: any[]) => void;
 8 | 
 9 | export interface StorageItem {
10 |   content: string;
11 |   queue: Callback[];
12 |   status: string;
13 | }
14 | 
15 | export const cacheStore: { [key: string]: StorageItem } = Object.create(null);
16 | 
17 | const SVG_FILE_NAME_REGEX = /(.+)\/(.+)\.svg$/;
18 | 
19 | const InlineSVG = ({ src }: { src: string }) => {
20 |   // testId will be the file name without extension (e.g. `public/img/icons/angle-double-down.svg` -> `angle-double-down`)
21 |   const testId = src.replace(SVG_FILE_NAME_REGEX, '$2');
22 |   return <svg xmlns="http://www.w3.org/2000/svg" data-testid={testId} viewBox="0 0 24 24" />;
23 | };
24 | 
25 | export default InlineSVG;
26 | 


--------------------------------------------------------------------------------
/.config/jest/utils.js:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * ⚠️⚠️⚠️ THIS FILE WAS SCAFFOLDED BY `@grafana/create-plugin`. DO NOT EDIT THIS FILE DIRECTLY. ⚠️⚠️⚠️
 3 |  *
 4 |  * In order to extend the configuration follow the steps in .config/README.md
 5 |  */
 6 | 
 7 | /*
 8 |  * This utility function is useful in combination with jest `transformIgnorePatterns` config
 9 |  * to transform specific packages (e.g.ES modules) in a projects node_modules folder.
10 |  */
11 | const nodeModulesToTransform = (moduleNames) => `node_modules\/(?!(${moduleNames.join('|')})\/)`;
12 | 
13 | // Array of known nested grafana package dependencies that only bundle an ESM version
14 | const grafanaESModules = [
15 |   '.pnpm', // Support using pnpm symlinked packages
16 |   '@grafana/schema',
17 |   'd3',
18 |   'd3-color',
19 |   'd3-force',
20 |   'd3-interpolate',
21 |   'd3-scale-chromatic',
22 |   'ol',
23 |   'react-colorful',
24 |   'rxjs',
25 |   'uuid',
26 | ];
27 | 
28 | module.exports = {
29 |   nodeModulesToTransform,
30 |   grafanaESModules,
31 | };
32 | 


--------------------------------------------------------------------------------
/.config/tsconfig.json:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * ⚠️⚠️⚠️ THIS FILE WAS SCAFFOLDED BY `@grafana/create-plugin`. DO NOT EDIT THIS FILE DIRECTLY. ⚠️⚠️⚠️
 3 |  *
 4 |  * In order to extend the configuration follow the steps in
 5 |  * https://grafana.github.io/plugin-tools/docs/advanced-configuration#extending-the-typescript-config
 6 |  */
 7 |  {
 8 |   "compilerOptions": {
 9 |     "alwaysStrict": true,
10 |     "declaration": false,
11 |     "rootDir": "../src",
12 |     "baseUrl": "../src",
13 |     "typeRoots": ["../node_modules/@types"],
14 |     "resolveJsonModule": true
15 |   },
16 |   "ts-node": {
17 |     "compilerOptions": {
18 |       "module": "commonjs",
19 |       "target": "es5",
20 |       "esModuleInterop": true
21 |     },
22 |     "transpileOnly": true
23 |   },
24 |   "include": ["../src", "./types"],
25 |   "extends": "@grafana/tsconfig"
26 | }
27 | 


--------------------------------------------------------------------------------
/.config/webpack/constants.ts:
--------------------------------------------------------------------------------
1 | export const SOURCE_DIR = 'src';
2 | export const DIST_DIR = 'dist';
3 | 


--------------------------------------------------------------------------------
/.config/webpack/utils.ts:
--------------------------------------------------------------------------------
 1 | import fs from 'fs';
 2 | import path from 'path';
 3 | import util from 'util';
 4 | import { glob } from 'glob';
 5 | import { SOURCE_DIR } from './constants';
 6 | 
 7 | export function getPackageJson() {
 8 |   return require(path.resolve(process.cwd(), 'package.json'));
 9 | }
10 | 
11 | export function getPluginJson() {
12 |   return require(path.resolve(process.cwd(), `${SOURCE_DIR}/plugin.json`));
13 | }
14 | 
15 | export function hasReadme() {
16 |   return fs.existsSync(path.resolve(process.cwd(), SOURCE_DIR, 'README.md'));
17 | }
18 | 
19 | // Support bundling nested plugins by finding all plugin.json files in src directory
20 | // then checking for a sibling module.[jt]sx? file.
21 | export async function getEntries(): Promise<Record<string, string>> {
22 |   const pluginsJson = await glob('**/src/**/plugin.json', { absolute: true });
23 | 
24 |   const plugins = await Promise.all(pluginsJson.map((pluginJson) => {
25 |       const folder = path.dirname(pluginJson);
26 |       return glob(`${folder}/module.{ts,tsx,js,jsx}`, { absolute: true });
27 |     })
28 |   );
29 | 
30 |   return plugins.reduce((result, modules) => {
31 |     return modules.reduce((result, module) => {
32 |       const pluginPath = path.dirname(module);
33 |       const pluginName = path.relative(process.cwd(), pluginPath).replace(/src\/?/i, '');
34 |       const entryName = pluginName === '' ? 'module' : `${pluginName}/module`;
35 | 
36 |       result[entryName] = module;
37 |       return result;
38 |     }, result);
39 |   }, {});
40 | }
41 | 


--------------------------------------------------------------------------------
/.config/webpack/webpack.config.ts:
--------------------------------------------------------------------------------
  1 | /*
  2 |  * ⚠️⚠️⚠️ THIS FILE WAS SCAFFOLDED BY `@grafana/create-plugin`. DO NOT EDIT THIS FILE DIRECTLY. ⚠️⚠️⚠️
  3 |  *
  4 |  * In order to extend the configuration follow the steps in
  5 |  * https://grafana.github.io/plugin-tools/docs/advanced-configuration#extending-the-webpack-config
  6 |  */
  7 | 
  8 | import CopyWebpackPlugin from 'copy-webpack-plugin';
  9 | import ESLintPlugin from 'eslint-webpack-plugin';
 10 | import ForkTsCheckerWebpackPlugin from 'fork-ts-checker-webpack-plugin';
 11 | import LiveReloadPlugin from 'webpack-livereload-plugin';
 12 | import path from 'path';
 13 | import ReplaceInFileWebpackPlugin from 'replace-in-file-webpack-plugin';
 14 | import { Configuration } from 'webpack';
 15 | 
 16 | import { getPackageJson, getPluginJson, hasReadme, getEntries } from './utils';
 17 | import { SOURCE_DIR, DIST_DIR } from './constants';
 18 | 
 19 | const pluginJson = getPluginJson();
 20 | 
 21 | const config = async (env): Promise<Configuration> => ({
 22 |   cache: {
 23 |     type: 'filesystem',
 24 |     buildDependencies: {
 25 |       config: [__filename],
 26 |     },
 27 |   },
 28 | 
 29 |   context: path.join(process.cwd(), SOURCE_DIR),
 30 | 
 31 |   devtool: env.production ? 'source-map' : 'eval-source-map',
 32 | 
 33 |   entry: await getEntries(),
 34 | 
 35 |   externals: [
 36 |     'lodash',
 37 |     'jquery',
 38 |     'moment',
 39 |     'slate',
 40 |     'emotion',
 41 |     '@emotion/react',
 42 |     '@emotion/css',
 43 |     'prismjs',
 44 |     'slate-plain-serializer',
 45 |     '@grafana/slate-react',
 46 |     'react',
 47 |     'react-dom',
 48 |     'react-redux',
 49 |     'redux',
 50 |     'rxjs',
 51 |     'react-router',
 52 |     'react-router-dom',
 53 |     'd3',
 54 |     '@grafana/ui',
 55 |     '@grafana/runtime',
 56 |     '@grafana/data',
 57 | 
 58 |     // Mark legacy SDK imports as external if their name starts with the "grafana/" prefix
 59 |     ({ request }, callback) => {
 60 |       const prefix = 'grafana/';
 61 |       const hasPrefix = (request) => request.indexOf(prefix) === 0;
 62 |       const stripPrefix = (request) => request.substr(prefix.length);
 63 | 
 64 |       if (hasPrefix(request)) {
 65 |         return callback(undefined, stripPrefix(request));
 66 |       }
 67 | 
 68 |       callback();
 69 |     },
 70 |   ],
 71 | 
 72 |   mode: env.production ? 'production' : 'development',
 73 | 
 74 |   module: {
 75 |     rules: [
 76 |       {
 77 |         exclude: /(node_modules)/,
 78 |         test: /\.[tj]sx?$/,
 79 |         use: {
 80 |           loader: 'swc-loader',
 81 |           options: {
 82 |             jsc: {
 83 |               baseUrl: './src',
 84 |               target: 'es2015',
 85 |               loose: false,
 86 |               parser: {
 87 |                 syntax: 'typescript',
 88 |                 tsx: true,
 89 |                 decorators: false,
 90 |                 dynamicImport: true,
 91 |               },
 92 |             },
 93 |           },
 94 |         },
 95 |       },
 96 |       {
 97 |         test: /\.css$/,
 98 |         use: ['style-loader', 'css-loader'],
 99 |       },
100 |       {
101 |         test: /\.s[ac]ss$/,
102 |         use: ['style-loader', 'css-loader', 'sass-loader'],
103 |       },
104 |       {
105 |         test: /\.(png|jpe?g|gif|svg)$/,
106 |         type: 'asset/resource',
107 |         generator: {
108 |           // Keep publicPath relative for host.com/grafana/ deployments
109 |           publicPath: `public/plugins/${pluginJson.id}/img/`,
110 |           outputPath: 'img/',
111 |           filename: Boolean(env.production) ? '[hash][ext]' : '[name][ext]',
112 |         },
113 |       },
114 |       {
115 |         test: /\.(woff|woff2|eot|ttf|otf)(\?v=\d+\.\d+\.\d+)?$/,
116 |         type: 'asset/resource',
117 |         generator: {
118 |           // Keep publicPath relative for host.com/grafana/ deployments
119 |           publicPath: `public/plugins/${pluginJson.id}/fonts/`,
120 |           outputPath: 'fonts/',
121 |           filename: Boolean(env.production) ? '[hash][ext]' : '[name][ext]',
122 |         },
123 |       },
124 |     ],
125 |   },
126 | 
127 |   output: {
128 |     clean: {
129 |       keep: new RegExp(`.*?_(amd64|arm(64)?)(.exe)?`),
130 |     },
131 |     filename: '[name].js',
132 |     library: {
133 |       type: 'amd',
134 |     },
135 |     path: path.resolve(process.cwd(), DIST_DIR),
136 |     publicPath: '/',
137 |   },
138 | 
139 |   plugins: [
140 |     new CopyWebpackPlugin({
141 |       patterns: [
142 |         // If src/README.md exists use it; otherwise the root README
143 |         // To `compiler.options.output`
144 |         { from: hasReadme() ? 'README.md' : '../README.md', to: '.', force: true },
145 |         { from: 'plugin.json', to: '.' },
146 |         { from: '../LICENSE', to: '.' },
147 |         { from: '../CHANGELOG.md', to: '.', force: true },
148 |         { from: '**/*.json', to: '.' }, // TODO<Add an error for checking the basic structure of the repo>
149 |         { from: '**/*.svg', to: '.', noErrorOnMissing: true }, // Optional
150 |         { from: '**/*.png', to: '.', noErrorOnMissing: true }, // Optional
151 |         { from: '**/*.html', to: '.', noErrorOnMissing: true }, // Optional
152 |         { from: 'img/**/*', to: '.', noErrorOnMissing: true }, // Optional
153 |         { from: 'libs/**/*', to: '.', noErrorOnMissing: true }, // Optional
154 |         { from: 'static/**/*', to: '.', noErrorOnMissing: true }, // Optional
155 |       ],
156 |     }),
157 |     // Replace certain template-variables in the README and plugin.json
158 |     new ReplaceInFileWebpackPlugin([
159 |       {
160 |         dir: DIST_DIR,
161 |         files: ['plugin.json', 'README.md'],
162 |         rules: [
163 |           {
164 |             search: /\%VERSION\%/g,
165 |             replace: getPackageJson().version,
166 |           },
167 |           {
168 |             search: /\%TODAY\%/g,
169 |             replace: new Date().toISOString().substring(0, 10),
170 |           },
171 |           {
172 |             search: /\%PLUGIN_ID\%/g,
173 |             replace: pluginJson.id,
174 |           },
175 |         ],
176 |       },
177 |     ]),
178 |     new ForkTsCheckerWebpackPlugin({
179 |       async: Boolean(env.development),
180 |       issue: {
181 |         include: [{ file: '**/*.{ts,tsx}' }],
182 |       },
183 |       typescript: { configFile: path.join(process.cwd(), 'tsconfig.json') },
184 |     }),
185 |     new ESLintPlugin({
186 |       extensions: ['.ts', '.tsx'],
187 |       lintDirtyModulesOnly: Boolean(env.development), // don't lint on start, only lint changed files
188 |     }),
189 |     ...(env.development ? [new LiveReloadPlugin()] : []),
190 |   ],
191 | 
192 |   resolve: {
193 |     extensions: ['.js', '.jsx', '.ts', '.tsx'],
194 |     // handle resolving "rootDir" paths
195 |     modules: [path.resolve(process.cwd(), 'src'), 'node_modules'],
196 |     unsafeCache: true,
197 |   },
198 | });
199 | 
200 | export default config;
201 | 


--------------------------------------------------------------------------------
/.eslintrc:
--------------------------------------------------------------------------------
1 | {
2 |   "extends": "./.config/.eslintrc"
3 | }


--------------------------------------------------------------------------------
/.gitattributes:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/grafana/strava-datasource/f662a4d133b862dc5cf78804ba16352846461110/.gitattributes


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | # Logs
 2 | logs
 3 | *.log
 4 | npm-debug.log*
 5 | 
 6 | # Runtime data
 7 | pids
 8 | *.pid
 9 | *.seed
10 | 
11 | # Directory for instrumented libs generated by jscoverage/JSCover
12 | lib-cov
13 | 
14 | # Coverage directory used by tools like istanbul
15 | coverage
16 | 
17 | # nyc test coverage
18 | .nyc_output
19 | 
20 | # Grunt intermediate storage (http://gruntjs.com/creating-plugins#storing-task-files)
21 | .grunt
22 | 
23 | # node-waf configuration
24 | .lock-wscript
25 | 
26 | # Compiled binary addons (http://nodejs.org/api/addons.html)
27 | build/Release
28 | 
29 | # Dependency directories
30 | node_modules
31 | jspm_packages
32 | vendor
33 | 
34 | # Optional npm cache directory
35 | .npm
36 | 
37 | # Optional REPL history
38 | .node_repl_history
39 | 
40 | # Dist folder
41 | dist/
42 | ci/
43 | 
44 | # Editor junk
45 | *.sublime-workspace
46 | *.swp
47 | .idea/
48 | *.iml
49 | *.tmp
50 | .vscode/
51 | 
52 | # lockfile
53 | package-lock.json
54 | 
55 | tmp/
56 | **/*.d.ts
57 | .eslintcache
58 | 


--------------------------------------------------------------------------------
/.nvmrc:
--------------------------------------------------------------------------------
1 | v22.11.0
2 | 


--------------------------------------------------------------------------------
/.prettierignore:
--------------------------------------------------------------------------------
1 | .git
2 | .github
3 | dist/
4 | pkg/
5 | node_modules
6 | *.d.ts
7 | coverage/
8 | ci/
9 | 


--------------------------------------------------------------------------------
/.prettierrc.js:
--------------------------------------------------------------------------------
1 | module.exports = {
2 |   // Prettier configuration provided by Grafana scaffolding
3 |   ...require("./.config/.prettierrc.js")
4 | };


--------------------------------------------------------------------------------
/CHANGELOG.md:
--------------------------------------------------------------------------------
  1 | # Change Log
  2 | 
  3 | ## [1.7.1] -
  4 | 
  5 | ### Fixed
  6 | 
  7 | - Fix error during initial authentication
  8 | - Set default grafana URL if empty
  9 | - Improved authentication UX
 10 | - Add note about externalServiceAccounts toggle
 11 | 
 12 | ## [1.7.0] - 2024-02-27
 13 | 
 14 | ### Changed
 15 | 
 16 | - Plugin uses service account to store and update refresh token in data source secure JSON data. Required Grafana 10.3 and `externalServiceAccounts` feature toggle to be enabled. Fixes re-authentication in Grafana Cloud.
 17 | - "Refresh token" authentication type removed and not supported anymore.
 18 | 
 19 | ## [1.6.1] - 2022-08-10
 20 | 
 21 | ### Fixed
 22 | 
 23 | - Invalid plugin signature after grafana restart
 24 | 
 25 | ## [1.6.0] - 2023-08-08
 26 | 
 27 | ### Added
 28 | 
 29 | - Authentication: Forward OAuth identity
 30 | - Add more data to geomap format
 31 | - Add Walk as a separate activity
 32 | - Display pace values in reverse order
 33 | 
 34 | ## [1.5.1] - 2022-09-08
 35 | 
 36 | ### Fixed
 37 | 
 38 | - 401 Unauthorized when connecting to Strava API, [#62](https://github.com/grafana/strava-datasource/issues/62)
 39 | 
 40 | ## [1.5.0] - 2022-08-24
 41 | 
 42 | ### Added
 43 | 
 44 | - Weighted average power metric, [#50](https://github.com/grafana/strava-datasource/issues/50)
 45 | - Improved caching (including data pre-fetching).
 46 | - Special _Pace_ stat which formats time based on activity type.
 47 | - Query segments data.
 48 | - Updated dashboards with data links navigation.
 49 | - Achievements stats.
 50 | - Activity route supports shared crosshair.
 51 | - More precise data streams handling.
 52 | - Build for Mac M1.
 53 | 
 54 | ## [1.4.1] - 2021-12-27
 55 | 
 56 | ### Fixed
 57 | 
 58 | - Dashboard data sources (fix broken dashboards)
 59 | 
 60 | ## [1.4.0] - 2021-12-27
 61 | 
 62 | ### Added
 63 | 
 64 | - Display activity route on the Geomap panel, [#49](https://github.com/grafana/strava-datasource/issues/49).
 65 | - Heatmap format which allows to visualize activities over selected time range as a heatmap on Geomap panel.
 66 | - Authentication by refresh token from the app config page.
 67 | - Automatically convert units based on user's preferences, [#43](https://github.com/grafana/strava-datasource/issues/43).
 68 | - Updates for the dashboards.
 69 | 
 70 | ## [1.3.0] - 2021-05-13
 71 | 
 72 | ### Added
 73 | 
 74 | - Individual activity query. Now it's possible to visualize activity-specific metrics: heart rate graph, speed/pace, splits and many other metrics.
 75 | - Template variables support (fetch list of activities and use activity it as a variable).
 76 | 
 77 | ## [1.2.0] - 2020-10-14
 78 | 
 79 | ### Added
 80 | 
 81 | - ARM build
 82 | 
 83 | ### Fixed
 84 | 
 85 | - Fix compatibility with Grafana 7.x
 86 | - Sign plugin
 87 | - Fix dashboards
 88 | 
 89 | ## [1.1.1] - 2020-03-05
 90 | 
 91 | ### Fixed
 92 | 
 93 | - Don't use git LFS for plugin binaries
 94 | 
 95 | ## [1.1.0] - 2020-03-05
 96 | 
 97 | ### Added
 98 | 
 99 | - Authentication on the backend, [#2](https://github.com/grafana/strava-datasource/issues/2)
100 | 
101 | ## [1.0.1] - 2020-01-10
102 | 
103 | ### Fixed
104 | 
105 | - Error handling while testing data source
106 | - Configuration docs link
107 | 
108 | ## [1.0.0] - 2020-01-09
109 | 
110 | ### Added
111 | 
112 | - Initial time series data support
113 | - Initial Worldmap panel format support
114 | - Activity type selection
115 | - Aggregation intervals
116 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | The MIT License (MIT)
 2 | 
 3 | Copyright (c) 2019 Grafana
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/Magefile.go:
--------------------------------------------------------------------------------
 1 | //+build mage
 2 | 
 3 | package main
 4 | 
 5 | import (
 6 | 	// mage:import
 7 | 	build "github.com/grafana/grafana-plugin-sdk-go/build"
 8 | )
 9 | 
10 | // Default configures the default target.
11 | var Default = build.BuildAll
12 | 


--------------------------------------------------------------------------------
/Makefile:
--------------------------------------------------------------------------------
 1 | arch-split = $(word $2,$(subst _, ,$1))
 2 | 
 3 | all: install build test
 4 | 
 5 | # Install dependencies
 6 | install: install-frontend install-backend
 7 | 
 8 | install-frontend:
 9 | 	yarn install --pure-lockfile
10 | 
11 | install-backend:
12 | 	go get -u golang.org/x/lint/golint
13 | 
14 | build: build-frontend build-backend
15 | build-frontend:
16 | 	yarn build
17 | 
18 | build-backend:
19 | 	env GOOS=linux go build -o ./dist/strava-plugin_linux_amd64 ./pkg
20 | 
21 | build-debug:
22 | 	env GOOS=linux go build -gcflags=all="-N -l" -o ./dist/strava-plugin_linux_amd64 ./pkg
23 | run-backend:
24 | 	# Rebuilds plugin on changes and kill running instance which forces grafana to restart plugin
25 | 	# See .bra.toml for bra configuration details
26 | 	bra run
27 | 
28 | dist: dist-frontend dist-backend
29 | dist-frontend:
30 | 	yarn build
31 | dist-backend: dist-backend-linux_amd64 dist-backend-linux_arm dist-backend-linux_arm64 dist-backend-darwin_amd64 dist-backend-darwin_arm64 dist-backend-windows_amd64
32 | dist-backend-windows_amd64: extension = .exe
33 | dist-backend-linux_arm:
34 | 	env GOOS=linux GOARCH=arm GOARM=6 go build -ldflags="-s -w" -o ./dist/strava-plugin_linux_arm ./pkg
35 | dist-backend-linux_arm64:
36 | 	env GOOS=linux GOARCH=arm64 go build -ldflags="-s -w" -o ./dist/strava-plugin_linux_arm64 ./pkg
37 | dist-backend-%:
38 | 	$(eval filename = strava-plugin_$*$(extension))
39 | 	env GOOS=$(call arch-split,$*,1) GO111MODULE=on GOARCH=$(call arch-split,$*,2) go build -ldflags="-s -w" -o ./dist/$(filename) ./pkg
40 | 
41 | run-frontend:
42 | 	yarn start
43 | 
44 | .PHONY: test
45 | test: test-frontend test-backend
46 | test-frontend:
47 | 	yarn test:ci
48 | test-backend:
49 | 	go test -v ./pkg/...
50 | test-ci:
51 | 	yarn ci-test
52 | 	mkdir -p tmp/coverage/golang/
53 | 	go test -race -coverprofile=tmp/coverage/golang/coverage.txt -covermode=atomic ./pkg/...
54 | 
55 | .PHONY: clean
56 | clean:
57 | 	-rm -r ./dist/
58 | 
59 | .PHONY: lint
60 | lint: lint-backend
61 | 
62 | lint-backend:
63 | 	golint -min_confidence=1.1 -set_exit_status pkg/...
64 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | # Strava datasource for Grafana
  2 | 
  3 | Visualize your sport activity with Grafana.
  4 | 
  5 | ![Strava Dashboards](https://user-images.githubusercontent.com/4932851/186380101-32565673-d16f-463a-bbe9-42cf2a9f376c.png)
  6 | 
  7 | Features:
  8 | 
  9 | - Query activities stats and present it as a time series data.
 10 | - Table format.
 11 | - Show activities over the world with [Geomap Panel](https://grafana.com/docs/grafana/latest/visualizations/geomap/).
 12 | - Visualize and analyze activity data such as heart rate, speed/pace, power, etc.
 13 | - Template variables support.
 14 | 
 15 | ## Configuration
 16 | 
 17 | In order to start using Strava datasource you will need to make a Strava API application.
 18 | 
 19 | 1. After you are logged in, go to https://www.strava.com/settings/api and create an app.
 20 | 2. Fill out the form fields:
 21 |    - Application name: pick any name you want, ie "grafana data source".
 22 |    - Category: choose app category, for example, "Visualizer".
 23 |    - Club: select a club if you want to associate app with a particular club.
 24 |    - Website: set to anything you want, it's used primarily for publicly available apps.
 25 |    - Application Description: add description if you want
 26 |    - **Authorization Callback Domain**: set it to domain you're using to access Grafana. If you're using Grafana at localhost, you can put anything here, `localhost` and `127.0.01` are white-listed. If you're running plugin at Grafana Cloud, set it to your cloud instance domain, ie `myorg.grafana.net`. If you're accessing grafana via IP-address, ie `192.168.1.10`, set callback domain to that address.
 27 | 3. You should see the “My API Application” page with Client ID, Client Secret and Refresh token and other information.
 28 | 
 29 | Learn more about Strava API applications at [Strava developer docs](https://developers.strava.com/docs/getting-started/#account).
 30 | 
 31 | ## Enable externalServiceAccounts feature
 32 | 
 33 | Plugin requires `externalServiceAccounts` feature toggle to be enabled. It could be done in config file:
 34 | 
 35 | ```ini
 36 | [feature_toggles]
 37 | externalServiceAccounts = true
 38 | ```
 39 | 
 40 | or through ENV variables:
 41 | 
 42 | ```yaml
 43 | services:
 44 |   # Grafana
 45 |   grafana:
 46 |     image: grafana/grafana:latest
 47 |     ports:
 48 |       - "3000:3000"
 49 |     environment:
 50 |       - GF_INSTALL_PLUGINS=grafana-strava-datasource
 51 |       - GF_FEATURE_TOGGLES_ENABLE=externalServiceAccounts
 52 | ```
 53 | 
 54 | Then go to grafana and create new Strava datasource.
 55 | 
 56 | ![New Data Source](docs/img/config_1.png)
 57 | 
 58 | Set desired data source name and fill _Client ID_ and _Client Secret_ fields with values obtained from Strava API application page. Save data source configuration (you'll get an error, but it's ok since data source not authorized yet). Then click _Connect with Strava_ button and authorize grafana datasource to connect to Strava.
 59 | 
 60 | ![Authorize datasource](docs/img/config_2.png)
 61 | 
 62 | If you get `redirect_uri invalid` error after clicking _Connect with Strava_, that means Authorization Callback Domain not properly configured. Get back to the Strava API application config and make sure you set it to exactly the same domain you use to open Grafana in your browser.
 63 | 
 64 | You will be redirected back to the datasource configuration page. Click _Save & Test_ button and if connection is properly configured, you will see _Data source is working_ message.
 65 | 
 66 | ![Save & Test](docs/img/config_3.png)
 67 | 
 68 | Now you can create some dashboards! Also, you can import dashboards from the _Dashboards_ tab at the data source configuration page.
 69 | 
 70 | ## Importing dashboards
 71 | 
 72 | Once data source is configured, you can import pre-configured dashboards from _Dashboards_ tab at the data source configuration page. That's a good starting point for your own custom dashboards.
 73 | 
 74 | Unfortunately, Strava API has some limitations and you can query only your own activities. But for multi-user dashboards you can configure multiple data sources and authorize separate users for each of them.
 75 | 
 76 | Some included dashboards depend on Grafana's new version of the panels or features which can be in alpha state in Grafana. If you want to [enable alpha panels](https://grafana.com/docs/grafana/latest/setup-grafana/configure-grafana/#enable_alpha) and avoid seeing an error message in the dashboard, set `GF_PANELS_ENABLE_ALPHA` environment variable to true. Example:
 77 | 
 78 | ```sh
 79 | export GF_PLUGINS_ENABLE_ALPHA=true
 80 | ```
 81 | 
 82 | or add config options to `grafana.ini`:
 83 | 
 84 | ```ini
 85 | [panels]
 86 | enable_alpha = true
 87 | ```
 88 | 
 89 | ## Advanced
 90 | 
 91 | ### Cache TTL
 92 | 
 93 | Plugin uses cache on the backend to store information of activities. This helps to reduce API usage and prevent rate limiting. Plugin basically caches everything except the list of activities on the "Strava Athlete Dashboard" (those activities cached, but with the short non-configurable interval). So if you updated activity information in Strava (ie, name, gear, etc), you don't see updates in Grafana until cache is refreshed. You can manually reset cache by clicking _Save and Test_ button at the data source config page.
 94 | 
 95 | ### Forward OAuth identity
 96 | 
 97 | It's possible to configure Grafana to authenticate users with Strava and then pass through OAuth identity to the data source.
 98 | This makes it possible for users to see its own data on dashboards without creating new data source for each user. To enable
 99 | Strava authentication, add this section to the grafana config file:
100 | 
101 | ```ini
102 | [auth.generic_oauth]
103 | name = Strava
104 | icon = signin
105 | enabled = true
106 | allow_sign_up = true
107 | client_id = YOUR_APP_CLIENT_ID
108 | client_secret = YOUR_APP_CLIENT_SECRET
109 | scopes = activity:read_all
110 | # Strava does not expose user's email, so use username to prevent error
111 | email_attribute_path = username
112 | login_attribute_path = username
113 | name_attribute_path = join(' ', [firstname, lastname])
114 | auth_url = https://www.strava.com/oauth/authorize
115 | token_url = https://www.strava.com/api/v3/oauth/token
116 | api_url = https://www.strava.com/api/v3/athlete
117 | ```
118 | 
119 | Restart grafana server, then activate _Forward OAuth Identity_ toggle in data source config and press _Save and test_ button.
120 | 


--------------------------------------------------------------------------------
/cspell.config.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "ignorePaths": [
 3 |     "coverage/**",
 4 |     "cypress/**",
 5 |     "dist/**",
 6 |     "go.sum",
 7 |     "mage_output_file.go",
 8 |     "node_modules/**",
 9 |     "provisioning/**/*.yaml",
10 |     "src/dashboards/*.json",
11 |     "**/testdata/**/*.json",
12 |     "**/testdata/**/*.jsonc",
13 |     "vendor/**",
14 |     "cspell.config.json",
15 |     "package.json",
16 |     "yarn.lock",
17 |     "docker-compose*.yaml",
18 |     "docker-compose*.yml"
19 |   ],
20 |   "ignoreRegExpList": [
21 |     "import\\s*\\((.|[\r\n])*?\\)",
22 |     "import\\s*.*\".*?\""
23 |   ],
24 |   "words": [
25 |     "grafana",
26 |     "datasource",
27 |     "datasources",
28 |     "strava",
29 |     "geomap",
30 |     "timeseries",
31 |     "tsdb",
32 |     "proxyfy",
33 |     "datapoints",
34 |     "heartrate",
35 |     "lengthmi",
36 |     "lengthm",
37 |     "lengthft",
38 |     "latlng",
39 |     "firstname",
40 |     "lastname",
41 |     "dthms",
42 |     "timeticks",
43 |     "instancemgmt",
44 |     "prefetcher",
45 |     "simplejson",
46 |     "preconfigured",
47 |     "httpadapter",
48 |     "gocache",
49 |     "hclog",
50 |     "ctxhttp",
51 |     "xoms",
52 |     "kudoed",
53 |     "connectwith",
54 |     "gtime",
55 |     "worldmap",
56 |     "backcountry",
57 |     "crossfit",
58 |     "handcycle",
59 |     "kitesurf",
60 |     "velomobile",
61 |     "backcountry",
62 |     "crossfit",
63 |     "handcycle",
64 |     "kitesurf",
65 |     "pickleball",
66 |     "velomobile",
67 |     "handcycle",
68 |     "velomobile",
69 |     "velocitymph",
70 |     "velocitykmh",
71 |     "kmph",
72 |     "minkm",
73 |     "signin",
74 |     "myorg",
75 |     "grafanaclient",
76 |     "httpclient"
77 |   ]
78 | }
79 | 


--------------------------------------------------------------------------------
/debug-backend.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | if [ "$1" == "-h" ]; then
 3 |   echo "Usage: ${BASH_SOURCE[0]} [plugin process name] [port]"
 4 |   exit
 5 | fi
 6 | 
 7 | PORT="${2:-3222}"
 8 | PLUGIN_NAME="${1:-strava-plugin}"
 9 | 
10 | if [ "$OSTYPE" == "linux-gnu" ]; then
11 |   ptrace_scope=`cat /proc/sys/kernel/yama/ptrace_scope`
12 |   if [ "$ptrace_scope" != 0 ]; then
13 |     echo "WARNING: ptrace_scope set to value other than 0, this might prevent debugger from connecting, try writing \"0\" to /proc/sys/kernel/yama/ptrace_scope.
14 | Read more at https://www.kernel.org/doc/Documentation/security/Yama.txt"
15 |     read -p "Set ptrace_scope to 0? y/N (default N)" set_ptrace_input
16 |     if [ "$set_ptrace_input" == "y" ] || [ "$set_ptrace_input" == "Y" ]; then
17 |       echo 0 | sudo tee /proc/sys/kernel/yama/ptrace_scope
18 |     fi
19 |   fi
20 | fi
21 | 
22 | PLUGIN_PID=`pgrep ${PLUGIN_NAME}`
23 | dlv attach ${PLUGIN_PID} --headless --listen=:${PORT} --api-version 2 --log
24 | pkill dlv
25 | 


--------------------------------------------------------------------------------
/devenv/docker-compose.yml:
--------------------------------------------------------------------------------
 1 | version: "3"
 2 | 
 3 | services:
 4 |   # Grafana
 5 |   grafana:
 6 |     image: grafana/grafana:latest
 7 |     ports:
 8 |       - "3001:3000"
 9 |     volumes:
10 |       - ../dist:/strava-datasource
11 |       - ./grafana.ini:/etc/grafana/grafana.ini:ro
12 |     environment:
13 |       - GF_SECURITY_ADMIN_PASSWORD=grafana
14 |       - GF_FEATURE_TOGGLES_ENABLE=externalServiceAccounts
15 | 


--------------------------------------------------------------------------------
/devenv/grafana.ini:
--------------------------------------------------------------------------------
 1 | app_mode = development
 2 | 
 3 | [log]
 4 | level = debug
 5 | 
 6 | [plugins]
 7 | enable_alpha = true
 8 | 
 9 | [plugin.strava-datasource]
10 | path = /strava-datasource
11 | 


--------------------------------------------------------------------------------
/docker-compose.yaml:
--------------------------------------------------------------------------------
 1 | version: '3.0'
 2 | 
 3 | services:
 4 |   grafana:
 5 |     container_name: 'grafana-strava-datasource'
 6 |     build:
 7 |       context: ./.config
 8 |       args:
 9 |         grafana_image: ${GRAFANA_IMAGE:-grafana-enterprise}
10 |         grafana_version: ${GRAFANA_VERSION:-9.5.3}
11 |     ports:
12 |       - 3000:3000/tcp
13 |     volumes:
14 |       - ./dist:/var/lib/grafana/plugins/grafana-strava-datasource
15 |       - ./provisioning:/etc/grafana/provisioning
16 | 


--------------------------------------------------------------------------------
/docs/configuration.md:
--------------------------------------------------------------------------------
 1 | # Strava Datasource Configuration
 2 | 
 3 | In order to start using Strava datasource you will need to make a Strava API application.
 4 | 
 5 | 1. After you are logged in, go to https://www.strava.com/settings/api and create an app.
 6 | 2. Fill out the form fields:
 7 |    - Application name: pick any name you want, ie "grafana data source".
 8 |    - Category: choose app category, for example, "Visualizer".
 9 |    - Club: select a club if you want to associate app with a particular club.
10 |    - Website: set to anything you want, it's used primarily for publicly available apps.
11 |    - Application Description: add description if you want
12 |    - **Authorization Callback Domain**: set it to domain you're using to access Grafana. If you're using Grafana at localhost, you can put anything here, `localhost` and `127.0.01` are white-listed. If you're running plugin at Grafana Cloud, set it to your cloud instance domain, ie `myorg.grafana.net`. If you're accessing grafana via IP-address, ie `192.168.1.10`, set callback domain to that address.
13 | 3. You should see the “My API Application” page with Client ID, Client Secret and Refresh token and other information.
14 | 
15 | Learn more about Strava API applications at [Strava developer docs](https://developers.strava.com/docs/getting-started/#account).
16 | 
17 | ## Enable externalServiceAccounts feature
18 | 
19 | Plugin requires `externalServiceAccounts` feature toggle to be enabled since version `1.7.0`. It could be done in config file:
20 | 
21 | ```ini
22 | [feature_toggles]
23 | externalServiceAccounts = true
24 | ```
25 | 
26 | or through ENV variables:
27 | 
28 | ```yaml
29 | services:
30 |   # Grafana
31 |   grafana:
32 |     image: grafana/grafana:latest
33 |     ports:
34 |       - "3000:3000"
35 |     environment:
36 |       - GF_INSTALL_PLUGINS=grafana-strava-datasource
37 |       - GF_FEATURE_TOGGLES_ENABLE=externalServiceAccounts
38 | ```
39 | 
40 | Then go to grafana and create new Strava datasource.
41 | 
42 | ![New Data Source](img/config_1.png)
43 | 
44 | Fill _Client ID_ field with value obtained from Strava API application page. Click _Connect with Strava_ button and authorize grafana datasource to connect to Strava.
45 | 
46 | ![Authorize datasource](img/config_2.png)
47 | 
48 | If you get `redirect_uri invalid` error after clicking _Connect with Strava_, that means Authorization Callback Domain not properly configured. Get back to the Strava API application config and make sure you set it to exactly the same domain you use to open Grafana in your browser.
49 | 
50 | You will be redirected back to the datasource configuration page. Now fill _Client ID_ and _Client Secret_ fields. Finally, set desired data source name and click _Save & Test_ button. If connection is properly configured, you will see _Data source is working_ message.
51 | 
52 | ![Save & Test](img/config_3.png)
53 | 
54 | Now you can create some dashboards! Also, you can import dashboards from the _Dashboards_ tab at the data source configuration page.
55 | 
56 | ## Forward OAuth identity
57 | 
58 | It's possible to configure Grafana to authenticate users with Strava and then pass through OAuth identity to the data source.
59 | This makes it possible for users to see its own data on dashboards without creating new data source for each user. To enable
60 | Strava authentication, add this section to the grafana config file:
61 | 
62 | ```ini
63 | [auth.generic_oauth]
64 | name = Strava
65 | icon = signin
66 | enabled = true
67 | allow_sign_up = true
68 | client_id = YOUR_APP_CLIENT_ID
69 | client_secret = YOUR_APP_CLIENT_SECRET
70 | scopes = activity:read_all
71 | # Strava does not expose user's email, so use username to prevent error
72 | email_attribute_path = username
73 | login_attribute_path = username
74 | name_attribute_path = join(' ', [firstname, lastname])
75 | auth_url = https://www.strava.com/oauth/authorize
76 | token_url = https://www.strava.com/api/v3/oauth/token
77 | api_url = https://www.strava.com/api/v3/athlete
78 | ```
79 | 
80 | Restart grafana server, then activate _Forward OAuth Identity_ toggle in data source config and press _Save and test_ button.
81 | 


--------------------------------------------------------------------------------
/docs/img/config_1.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/grafana/strava-datasource/f662a4d133b862dc5cf78804ba16352846461110/docs/img/config_1.png


--------------------------------------------------------------------------------
/docs/img/config_2.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/grafana/strava-datasource/f662a4d133b862dc5cf78804ba16352846461110/docs/img/config_2.png


--------------------------------------------------------------------------------
/docs/img/config_3.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/grafana/strava-datasource/f662a4d133b862dc5cf78804ba16352846461110/docs/img/config_3.png


--------------------------------------------------------------------------------
/go.mod:
--------------------------------------------------------------------------------
  1 | module github.com/grafana/strava-datasource
  2 | 
  3 | go 1.23.5
  4 | 
  5 | require (
  6 | 	github.com/bitly/go-simplejson v0.5.1
  7 | 	github.com/grafana/grafana-plugin-sdk-go v0.274.0
  8 | 	github.com/hashicorp/go-hclog v1.6.3
  9 | 	github.com/patrickmn/go-cache v2.1.0+incompatible
 10 | 	golang.org/x/net v0.37.0
 11 | )
 12 | 
 13 | require (
 14 | 	github.com/BurntSushi/toml v1.4.0 // indirect
 15 | 	github.com/apache/arrow-go/v18 v18.2.0 // indirect
 16 | 	github.com/beorn7/perks v1.0.1 // indirect
 17 | 	github.com/cenkalti/backoff/v4 v4.3.0 // indirect
 18 | 	github.com/cespare/xxhash/v2 v2.3.0 // indirect
 19 | 	github.com/cheekybits/genny v1.0.0 // indirect
 20 | 	github.com/chromedp/cdproto v0.0.0-20220208224320-6efb837e6bc2 // indirect
 21 | 	github.com/cpuguy83/go-md2man/v2 v2.0.6 // indirect
 22 | 	github.com/elazarl/goproxy v1.7.2 // indirect
 23 | 	github.com/fatih/color v1.18.0 // indirect
 24 | 	github.com/getkin/kin-openapi v0.130.0 // indirect
 25 | 	github.com/go-logr/logr v1.4.2 // indirect
 26 | 	github.com/go-logr/stdr v1.2.2 // indirect
 27 | 	github.com/go-openapi/jsonpointer v0.21.1 // indirect
 28 | 	github.com/go-openapi/swag v0.23.1 // indirect
 29 | 	github.com/goccy/go-json v0.10.5 // indirect
 30 | 	github.com/gogo/protobuf v1.3.2 // indirect
 31 | 	github.com/golang/protobuf v1.5.4 // indirect
 32 | 	github.com/google/flatbuffers v25.2.10+incompatible // indirect
 33 | 	github.com/google/go-cmp v0.7.0 // indirect
 34 | 	github.com/google/uuid v1.6.0 // indirect
 35 | 	github.com/gorilla/mux v1.8.1 // indirect
 36 | 	github.com/grafana/otel-profiling-go v0.5.1 // indirect
 37 | 	github.com/grafana/pyroscope-go/godeltaprof v0.1.8 // indirect
 38 | 	github.com/grpc-ecosystem/go-grpc-middleware/providers/prometheus v1.0.1 // indirect
 39 | 	github.com/grpc-ecosystem/go-grpc-middleware/v2 v2.3.1 // indirect
 40 | 	github.com/grpc-ecosystem/grpc-gateway/v2 v2.26.3 // indirect
 41 | 	github.com/hashicorp/go-plugin v1.6.3 // indirect
 42 | 	github.com/hashicorp/yamux v0.1.2 // indirect
 43 | 	github.com/josharian/intern v1.0.0 // indirect
 44 | 	github.com/json-iterator/go v1.1.12 // indirect
 45 | 	github.com/jszwedko/go-datemath v0.1.1-0.20230526204004-640a500621d6 // indirect
 46 | 	github.com/klauspost/compress v1.18.0 // indirect
 47 | 	github.com/klauspost/cpuid/v2 v2.2.10 // indirect
 48 | 	github.com/magefile/mage v1.15.0 // indirect
 49 | 	github.com/mailru/easyjson v0.9.0 // indirect
 50 | 	github.com/mattetti/filebuffer v1.0.1 // indirect
 51 | 	github.com/mattn/go-colorable v0.1.14 // indirect
 52 | 	github.com/mattn/go-isatty v0.0.20 // indirect
 53 | 	github.com/mattn/go-runewidth v0.0.16 // indirect
 54 | 	github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect
 55 | 	github.com/modern-go/reflect2 v1.0.2 // indirect
 56 | 	github.com/mohae/deepcopy v0.0.0-20170929034955-c48cc78d4826 // indirect
 57 | 	github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 // indirect
 58 | 	github.com/oasdiff/yaml v0.0.0-20250309154309-f31be36b4037 // indirect
 59 | 	github.com/oasdiff/yaml3 v0.0.0-20250309153720-d2182401db90 // indirect
 60 | 	github.com/oklog/run v1.1.0 // indirect
 61 | 	github.com/olekukonko/tablewriter v0.0.5 // indirect
 62 | 	github.com/perimeterx/marshmallow v1.1.5 // indirect
 63 | 	github.com/pierrec/lz4/v4 v4.1.22 // indirect
 64 | 	github.com/prometheus/client_golang v1.21.1 // indirect
 65 | 	github.com/prometheus/client_model v0.6.1 // indirect
 66 | 	github.com/prometheus/common v0.63.0 // indirect
 67 | 	github.com/prometheus/procfs v0.15.1 // indirect
 68 | 	github.com/rivo/uniseg v0.4.4 // indirect
 69 | 	github.com/russross/blackfriday/v2 v2.1.0 // indirect
 70 | 	github.com/unknwon/bra v0.0.0-20200517080246-1e3013ecaff8 // indirect
 71 | 	github.com/unknwon/com v1.0.1 // indirect
 72 | 	github.com/unknwon/log v0.0.0-20200308114134-929b1006e34a // indirect
 73 | 	github.com/urfave/cli v1.22.16 // indirect
 74 | 	github.com/zeebo/xxh3 v1.0.2 // indirect
 75 | 	go.opentelemetry.io/auto/sdk v1.1.0 // indirect
 76 | 	go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.60.0 // indirect
 77 | 	go.opentelemetry.io/contrib/instrumentation/net/http/httptrace/otelhttptrace v0.60.0 // indirect
 78 | 	go.opentelemetry.io/contrib/propagators/jaeger v1.35.0 // indirect
 79 | 	go.opentelemetry.io/contrib/samplers/jaegerremote v0.29.0 // indirect
 80 | 	go.opentelemetry.io/otel v1.35.0 // indirect
 81 | 	go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.35.0 // indirect
 82 | 	go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.35.0 // indirect
 83 | 	go.opentelemetry.io/otel/metric v1.35.0 // indirect
 84 | 	go.opentelemetry.io/otel/sdk v1.35.0 // indirect
 85 | 	go.opentelemetry.io/otel/trace v1.35.0 // indirect
 86 | 	go.opentelemetry.io/proto/otlp v1.5.0 // indirect
 87 | 	golang.org/x/exp v0.0.0-20250305212735-054e65f0b394 // indirect
 88 | 	golang.org/x/mod v0.24.0 // indirect
 89 | 	golang.org/x/sync v0.12.0 // indirect
 90 | 	golang.org/x/sys v0.31.0 // indirect
 91 | 	golang.org/x/text v0.23.0 // indirect
 92 | 	golang.org/x/tools v0.31.0 // indirect
 93 | 	golang.org/x/xerrors v0.0.0-20240903120638-7835f813f4da // indirect
 94 | 	google.golang.org/genproto/googleapis/api v0.0.0-20250313205543-e70fdf4c4cb4 // indirect
 95 | 	google.golang.org/genproto/googleapis/rpc v0.0.0-20250313205543-e70fdf4c4cb4 // indirect
 96 | 	google.golang.org/grpc v1.71.0 // indirect
 97 | 	google.golang.org/protobuf v1.36.5 // indirect
 98 | 	gopkg.in/fsnotify/fsnotify.v1 v1.4.7 // indirect
 99 | 	gopkg.in/yaml.v3 v3.0.1 // indirect
100 | )
101 | 


--------------------------------------------------------------------------------
/jest-setup.js:
--------------------------------------------------------------------------------
1 | // Jest setup provided by Grafana scaffolding
2 | import './.config/jest-setup';
3 | 


--------------------------------------------------------------------------------
/jest.config.js:
--------------------------------------------------------------------------------
1 | // force timezone to UTC to allow tests to work regardless of local timezone
2 | // generally used by snapshots, but can affect specific tests
3 | process.env.TZ = 'UTC';
4 | 
5 | module.exports = {
6 |   // Jest configuration provided by Grafana scaffolding
7 |   ...require('./.config/jest.config'),
8 | };
9 | 


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "grafana-strava-datasource",
 3 |   "description": "Strava Datasource for Grafana",
 4 |   "version": "1.7.2",
 5 |   "homepage": "https://grafana.com/plugins/grafana-strava-datasource",
 6 |   "author": "Grafana Labs <team@grafana.com> (https://grafana.com)",
 7 |   "license": "SEE LICENSE IN LICENSE",
 8 |   "bugs": {
 9 |     "email": "plugins@grafana.com"
10 |   },
11 |   "private": true,
12 |   "scripts": {
13 |     "build": "webpack -c ./.config/webpack/webpack.config.ts --env production",
14 |     "ci-test": "jest --config jest.config.js",
15 |     "dev": "webpack -w -c ./.config/webpack/webpack.config.ts --env development",
16 |     "e2e": "yarn exec cypress install && yarn exec grafana-e2e run",
17 |     "e2e:update": "yarn exec cypress install && yarn exec grafana-e2e run --update-screenshots",
18 |     "jest": "jest --config jest.config.js --notify --watch",
19 |     "lint": "eslint --cache --ignore-path ./.gitignore --ext .js,.jsx,.ts,.tsx .",
20 |     "lint:fix": "yarn run lint --fix",
21 |     "server": "docker-compose up --build",
22 |     "sign": "npx --yes @grafana/sign-plugin@latest",
23 |     "test": "jest --watch --onlyChanged",
24 |     "test:ci": "jest --passWithNoTests --maxWorkers 4",
25 |     "typecheck": "tsc --noEmit",
26 |     "spellcheck": "cspell -c cspell.config.json \"**/*.{ts,tsx,js,go,md,mdx,yml,yaml,json,scss,css}\""
27 |   },
28 |   "devDependencies": {
29 |     "@babel/core": "^7.26.10",
30 |     "@babel/preset-env": "^7.26.9",
31 |     "@grafana/e2e": "10.4.12",
32 |     "@grafana/e2e-selectors": "11.5.2",
33 |     "@grafana/eslint-config": "^8.0.0",
34 |     "@grafana/tsconfig": "^2.0.0",
35 |     "@swc/core": "1.3.75",
36 |     "@swc/helpers": "^0.5.15",
37 |     "@swc/jest": "^0.2.37",
38 |     "@testing-library/dom": "^10.4.0",
39 |     "@testing-library/jest-dom": "6.4.2",
40 |     "@testing-library/react": "14.2.2",
41 |     "@testing-library/user-event": "^14.6.1",
42 |     "@types/jest": "^29.5.14",
43 |     "@types/jquery": "^3.5.32",
44 |     "@types/lodash": "^4.17.16",
45 |     "@types/node": "^22.13.10",
46 |     "@types/react": "^19.0.10",
47 |     "copy-webpack-plugin": "^13.0.0",
48 |     "cspell": "8.17.5",
49 |     "css-loader": "^7.1.2",
50 |     "@stylistic/eslint-plugin-ts": "^3.1.0",
51 |     "@types/testing-library__jest-dom": "5.14.8",
52 |     "@typescript-eslint/eslint-plugin": "^7.0.0",
53 |     "@typescript-eslint/parser": "^6.18.0",
54 |     "eslint": "^8.0.0",
55 |     "eslint-config-prettier": "^10.1.1",
56 |     "eslint-plugin-jsdoc": "^50.6.8",
57 |     "eslint-plugin-react": "^7.33.0",
58 |     "eslint-plugin-react-hooks": "^5.2.0",
59 |     "eslint-webpack-plugin": "^4.0.1",
60 |     "fork-ts-checker-webpack-plugin": "^9.0.2",
61 |     "glob": "^11.0.1",
62 |     "identity-obj-proxy": "3.0.0",
63 |     "jest": "^29.7.0",
64 |     "jest-environment-jsdom": "^29.7.0",
65 |     "lodash": "^4.17.11",
66 |     "prettier": "^3.5.3",
67 |     "react-use": "17.6.0",
68 |     "replace-in-file-webpack-plugin": "^1.0.6",
69 |     "sass": "1.85.1",
70 |     "sass-loader": "16.0.5",
71 |     "style-loader": "4.0.0",
72 |     "swc-loader": "^0.2.6",
73 |     "ts-jest": "^29.2.6",
74 |     "ts-node": "^10.9.2",
75 |     "tsconfig-paths": "^4.2.0",
76 |     "typescript": "5.5.4",
77 |     "webpack": "^5.98.0",
78 |     "webpack-cli": "^6.0.1",
79 |     "webpack-livereload-plugin": "^3.0.2"
80 |   },
81 |   "dependencies": {
82 |     "@emotion/css": "^11.13.5",
83 |     "@emotion/react": "11.14.0",
84 |     "@grafana/data": "11.5.2",
85 |     "@grafana/runtime": "11.5.2",
86 |     "@grafana/ui": "11.5.2",
87 |     "react": "18.2.0",
88 |     "react-dom": "18.2.0",
89 |     "rxjs": "7.8.1",
90 |     "tslib": "2.6.2"
91 |   },
92 |   "resolutions": {
93 |     "@babel/preset-env": "^7.8.7"
94 |   },
95 |   "packageManager": "yarn@1.22.19"
96 | }
97 | 


--------------------------------------------------------------------------------
/pkg/datasource/datasource.go:
--------------------------------------------------------------------------------
  1 | package datasource
  2 | 
  3 | import (
  4 | 	"bytes"
  5 | 	"context"
  6 | 	"crypto/tls"
  7 | 	"encoding/json"
  8 | 	"errors"
  9 | 	"fmt"
 10 | 	"io"
 11 | 	"net"
 12 | 	"net/http"
 13 | 	"net/url"
 14 | 	"regexp"
 15 | 	"strconv"
 16 | 	"strings"
 17 | 	"time"
 18 | 
 19 | 	simplejson "github.com/bitly/go-simplejson"
 20 | 	"github.com/grafana/strava-datasource/pkg/grafanaclient"
 21 | 	"golang.org/x/net/context/ctxhttp"
 22 | 
 23 | 	"github.com/grafana/grafana-plugin-sdk-go/backend"
 24 | 	"github.com/grafana/grafana-plugin-sdk-go/backend/datasource"
 25 | 	"github.com/grafana/grafana-plugin-sdk-go/backend/gtime"
 26 | 	"github.com/grafana/grafana-plugin-sdk-go/backend/instancemgmt"
 27 | 	"github.com/grafana/grafana-plugin-sdk-go/backend/log"
 28 | )
 29 | 
 30 | const StravaAPIUrl = "https://www.strava.com/api/v3"
 31 | const StravaAPITokenUrl = "https://www.strava.com/api/v3/oauth/token"
 32 | 
 33 | const StravaApiQueryType = "stravaAPI"
 34 | const StravaAuthQueryType = "stravaAuth"
 35 | 
 36 | var ErrAlertingNotSupported = errors.New("alerting not supported")
 37 | 
 38 | type StravaDatasourcePlugin struct {
 39 | 	im      instancemgmt.InstanceManager
 40 | 	dataDir string
 41 | 	saToken string
 42 | 	logger  log.Logger
 43 | }
 44 | 
 45 | // StravaDatasourceInstance stores state about a specific datasource
 46 | // and provides methods to make requests to the Strava API
 47 | type StravaDatasourceInstance struct {
 48 | 	dsInfo        *backend.DataSourceInstanceSettings
 49 | 	cache         *DSCache
 50 | 	logger        log.Logger
 51 | 	httpClient    *http.Client
 52 | 	prefetcher    *StravaPrefetcher
 53 | 	saToken       string
 54 | 	grafanaClient grafanaclient.GrafanaHTTPClient
 55 | }
 56 | 
 57 | func NewStravaDatasourcePlugin(dataDir string, saToken string) *StravaDatasourcePlugin {
 58 | 	im := datasource.NewInstanceManager(newInstanceWithDataDir(dataDir, saToken))
 59 | 	return &StravaDatasourcePlugin{
 60 | 		im:      im,
 61 | 		dataDir: dataDir,
 62 | 		saToken: saToken,
 63 | 		logger:  log.New(),
 64 | 	}
 65 | }
 66 | 
 67 | func newInstanceWithDataDir(dataDir string, saToken string) func(context.Context, backend.DataSourceInstanceSettings) (instancemgmt.Instance, error) {
 68 | 	return func(ctx context.Context, settings backend.DataSourceInstanceSettings) (instancemgmt.Instance, error) {
 69 | 		return newStravaDatasourceInstance(ctx, settings, dataDir, saToken)
 70 | 	}
 71 | }
 72 | 
 73 | // newStravaDatasourceInstance returns an initialized datasource instance
 74 | func newStravaDatasourceInstance(ctx context.Context, settings backend.DataSourceInstanceSettings, dataDir string, saToken string) (instancemgmt.Instance, error) {
 75 | 	logger := log.New()
 76 | 	logger.Debug("Initializing new data source instance")
 77 | 
 78 | 	settingsDTO := &StravaDatasourceSettingsDTO{}
 79 | 	err := json.Unmarshal(settings.JSONData, settingsDTO)
 80 | 	if err != nil {
 81 | 		return nil, fmt.Errorf("cannot read data source settings: %w", err)
 82 | 	}
 83 | 
 84 | 	if settingsDTO.CacheTTL == "" {
 85 | 		settingsDTO.CacheTTL = "1h"
 86 | 	}
 87 | 
 88 | 	cacheTTL, err := gtime.ParseInterval(settingsDTO.CacheTTL)
 89 | 	if err != nil {
 90 | 		log.DefaultLogger.Warn("Cannot read cache TTL", "error", err)
 91 | 	}
 92 | 
 93 | 	grafanaClient, err := grafanaclient.NewGrafanaHTTPClient(ctx, settings, saToken)
 94 | 	if err != nil {
 95 | 		return nil, fmt.Errorf("cannot create grafana client: %w", err)
 96 | 	}
 97 | 
 98 | 	dsInstance := &StravaDatasourceInstance{
 99 | 		dsInfo:        &settings,
100 | 		logger:        logger,
101 | 		cache:         NewDSCache(&settings, cacheTTL, 10*time.Minute, dataDir),
102 | 		saToken:       saToken,
103 | 		grafanaClient: grafanaClient,
104 | 		httpClient: &http.Client{
105 | 			Transport: &http.Transport{
106 | 				TLSClientConfig: &tls.Config{
107 | 					Renegotiation: tls.RenegotiateFreelyAsClient,
108 | 				},
109 | 				Proxy: http.ProxyFromEnvironment,
110 | 				Dial: (&net.Dialer{
111 | 					Timeout:   30 * time.Second,
112 | 					KeepAlive: 30 * time.Second,
113 | 				}).Dial,
114 | 				TLSHandshakeTimeout:   10 * time.Second,
115 | 				ExpectContinueTimeout: 1 * time.Second,
116 | 				MaxIdleConns:          100,
117 | 				IdleConnTimeout:       90 * time.Second,
118 | 			},
119 | 			Timeout: time.Duration(time.Second * 30),
120 | 		},
121 | 	}
122 | 
123 | 	oauthPassThru := isOAuthPassThruEnabled(dsInstance)
124 | 	if !oauthPassThru {
125 | 		// Initialize and run prefetcher
126 | 		prefetcher := NewStravaPrefetcher(5, dsInstance)
127 | 		dsInstance.prefetcher = prefetcher
128 | 		go func() {
129 | 			dsInstance.prefetcher.Run()
130 | 		}()
131 | 	}
132 | 
133 | 	return dsInstance, nil
134 | }
135 | 
136 | // getDSInstance Returns cached datasource or creates new one
137 | func (ds *StravaDatasourcePlugin) getDSInstance(ctx context.Context, pluginContext backend.PluginContext) (*StravaDatasourceInstance, error) {
138 | 	instance, err := ds.im.Get(ctx, pluginContext)
139 | 	if err != nil {
140 | 		return nil, err
141 | 	}
142 | 	return instance.(*StravaDatasourceInstance), nil
143 | }
144 | 
145 | func (ds *StravaDatasourcePlugin) QueryData(ctx context.Context, req *backend.QueryDataRequest) (*backend.QueryDataResponse, error) {
146 | 	qdr := backend.NewQueryDataResponse()
147 | 
148 | 	for _, q := range req.Queries {
149 | 		res := backend.DataResponse{}
150 | 		res.Error = ErrAlertingNotSupported
151 | 		qdr.Responses[q.RefID] = res
152 | 	}
153 | 
154 | 	return qdr, nil
155 | }
156 | 
157 | // CheckHealth checks if the plugin is running properly
158 | func (ds *StravaDatasourcePlugin) CheckHealth(ctx context.Context, req *backend.CheckHealthRequest) (*backend.CheckHealthResult, error) {
159 | 	res := &backend.CheckHealthResult{}
160 | 
161 | 	_, err := ds.getDSInstance(ctx, req.PluginContext)
162 | 	if err != nil {
163 | 		res.Status = backend.HealthStatusError
164 | 		res.Message = "Error getting datasource instance"
165 | 		ds.logger.Error("Error getting datasource instance", "err", err)
166 | 		return res, nil
167 | 	}
168 | 
169 | 	// TODO: implement real API health check
170 | 	res.Status = backend.HealthStatusOk
171 | 	res.Message = "Plugin up and running"
172 | 	return res, nil
173 | }
174 | 
175 | func (ds *StravaDatasourceInstance) StravaAuthQuery(ctx context.Context, req *StravaAuthRequest) (*StravaAuthResourceResponse, error) {
176 | 	ds.logger.Debug("Performing authentication")
177 | 	authCode := req.AuthCode
178 | 	_, err := ds.ExchangeToken(authCode)
179 | 	if err != nil {
180 | 		return nil, err
181 | 	}
182 | 
183 | 	tokenExchangeResp := map[string]string{
184 | 		"message": "Authorization code successfully exchanged for refresh token",
185 | 	}
186 | 
187 | 	response := &StravaAuthResourceResponse{
188 | 		Result: tokenExchangeResp,
189 | 	}
190 | 	return response, nil
191 | }
192 | 
193 | func (ds *StravaDatasourceInstance) GetAccessToken() (string, error) {
194 | 	accessToken, expTime, found := ds.cache.gocache.GetWithExpiration("accessToken")
195 | 	accessTokenExpired := time.Now().After(expTime)
196 | 	if found && !accessTokenExpired {
197 | 		return accessToken.(string), nil
198 | 	} else if found && accessTokenExpired {
199 | 		ds.logger.Debug("Access token expired, obtaining new one")
200 | 	}
201 | 
202 | 	refreshToken, err := ds.GetRefreshToken()
203 | 	if err != nil {
204 | 		return "", err
205 | 	}
206 | 
207 | 	tokenResp, err := ds.RefreshAccessToken(refreshToken)
208 | 	if err != nil {
209 | 		ds.logger.Error(err.Error())
210 | 		return "", err
211 | 	}
212 | 
213 | 	return tokenResp.AccessToken, nil
214 | }
215 | 
216 | func (ds *StravaDatasourceInstance) GetRefreshToken() (string, error) {
217 | 	cachedToken, found := ds.cache.Get("refreshToken")
218 | 	if found {
219 | 		ds.logger.Debug("Got refresh token from cache")
220 | 		return cachedToken.(string), nil
221 | 	}
222 | 
223 | 	secureJsonData := ds.dsInfo.DecryptedSecureJSONData
224 | 	refreshToken := secureJsonData["refreshToken"]
225 | 	if refreshToken == "" {
226 | 		ds.logger.Error("Error loading refresh token")
227 | 		return "", errors.New("Refresh token not found, authorize datasource first")
228 | 	}
229 | 
230 | 	ds.logger.Debug("Got refresh token from secureJsonData")
231 | 	return refreshToken, nil
232 | }
233 | 
234 | // SaveRefreshToken saves refresh token in secureJsonData by calling update data source API endpoint
235 | func (ds *StravaDatasourceInstance) SaveRefreshToken(token string) error {
236 | 	ds.logger.Debug("saving refresh token")
237 | 	ds.cache.SetWithNoExpiration("refreshToken", token)
238 | 
239 | 	res, err := ds.grafanaClient.Get(fmt.Sprintf("/api/datasources/uid/%s", ds.dsInfo.UID))
240 | 	if err != nil {
241 | 		return err
242 | 	}
243 | 	defer res.Body.Close()
244 | 	body, err := io.ReadAll(res.Body)
245 | 	if err != nil {
246 | 		return err
247 | 	}
248 | 
249 | 	jsonData := make(map[string]any)
250 | 	err = json.Unmarshal(body, &jsonData)
251 | 	if err != nil {
252 | 		return err
253 | 	}
254 | 	secureJsonData := make(map[string]string)
255 | 	secureJsonData["refreshToken"] = token
256 | 	jsonData["secureJsonData"] = secureJsonData
257 | 
258 | 	updatedData, err := json.Marshal(jsonData)
259 | 	if err != nil {
260 | 		return err
261 | 	}
262 | 
263 | 	reqData := bytes.NewReader(updatedData)
264 | 	updateRes, err := ds.grafanaClient.DoRequest("PUT", fmt.Sprintf("/api/datasources/uid/%s", ds.dsInfo.UID), reqData)
265 | 	if err != nil {
266 | 		return err
267 | 	}
268 | 	ds.logger.Debug("data source updated", "status", updateRes.Status)
269 | 
270 | 	return nil
271 | }
272 | 
273 | // ExchangeToken invokes first time when authentication required and exchange authorization code for the
274 | // access and refresh tokens
275 | // https://developers.strava.com/docs/authentication/#tokenexchange
276 | func (ds *StravaDatasourceInstance) ExchangeToken(authCode string) (*TokenExchangeResponse, error) {
277 | 	jsonDataStr := ds.dsInfo.JSONData
278 | 	jsonData, err := simplejson.NewJson([]byte(jsonDataStr))
279 | 	if err != nil {
280 | 		return nil, err
281 | 	}
282 | 	clientId := jsonData.Get("clientID").MustString()
283 | 
284 | 	secureJsonData := ds.dsInfo.DecryptedSecureJSONData
285 | 	clientSecret := secureJsonData["clientSecret"]
286 | 
287 | 	authParams := map[string][]string{
288 | 		"client_id":     {clientId},
289 | 		"client_secret": {clientSecret},
290 | 		"code":          {authCode},
291 | 		"grant_type":    {"authorization_code"},
292 | 	}
293 | 
294 | 	authResp, err := ds.httpClient.PostForm(StravaAPITokenUrl, authParams)
295 | 	if err != nil {
296 | 		return nil, err
297 | 	} else if authResp.StatusCode != http.StatusOK {
298 | 		return nil, fmt.Errorf("Auth error, status: %v", authResp.Status)
299 | 	}
300 | 
301 | 	defer authResp.Body.Close()
302 | 	body, err := io.ReadAll(authResp.Body)
303 | 	if err != nil {
304 | 		return nil, err
305 | 	}
306 | 
307 | 	respJson, err := simplejson.NewJson(body)
308 | 	if err != nil {
309 | 		return nil, err
310 | 	}
311 | 
312 | 	accessToken := respJson.Get("access_token").MustString()
313 | 	accessTokenExpAt := respJson.Get("expires_at").MustInt64()
314 | 	accessTokenExpIn := time.Until(time.Unix(accessTokenExpAt, 0))
315 | 	refreshToken := respJson.Get("refresh_token").MustString()
316 | 	ds.logger.Debug("Got new refresh token")
317 | 
318 | 	ds.cache.SetWithExpiration("accessToken", accessToken, accessTokenExpIn)
319 | 	err = ds.SaveRefreshToken(refreshToken)
320 | 	if err != nil {
321 | 		ds.logger.Error("Error saving refresh token", "err", err)
322 | 		return nil, fmt.Errorf("Error saving refresh token: %v", err)
323 | 	}
324 | 
325 | 	return &TokenExchangeResponse{
326 | 		AccessToken:      accessToken,
327 | 		AccessTokenExpAt: accessTokenExpAt,
328 | 		RefreshToken:     refreshToken,
329 | 	}, nil
330 | }
331 | 
332 | // RefreshAccessToken refreshes expired Access token using refresh token
333 | // https://developers.strava.com/docs/authentication/#refreshingexpiredaccesstokens
334 | func (ds *StravaDatasourceInstance) RefreshAccessToken(refreshToken string) (*TokenExchangeResponse, error) {
335 | 	jsonDataStr := ds.dsInfo.JSONData
336 | 	jsonData, err := simplejson.NewJson([]byte(jsonDataStr))
337 | 	if err != nil {
338 | 		return nil, err
339 | 	}
340 | 	clientId := jsonData.Get("clientID").MustString()
341 | 
342 | 	secureJsonData := ds.dsInfo.DecryptedSecureJSONData
343 | 	clientSecret := secureJsonData["clientSecret"]
344 | 
345 | 	authParams := map[string][]string{
346 | 		"client_id":     {clientId},
347 | 		"client_secret": {clientSecret},
348 | 		"refresh_token": {refreshToken},
349 | 		"grant_type":    {"refresh_token"},
350 | 	}
351 | 
352 | 	authResp, err := ds.httpClient.PostForm(StravaAPITokenUrl, authParams)
353 | 	if err != nil {
354 | 		return nil, err
355 | 	}
356 | 	if authResp.StatusCode != http.StatusOK {
357 | 		return nil, fmt.Errorf("Token exchange failed: %v", authResp.Status)
358 | 	}
359 | 
360 | 	defer authResp.Body.Close()
361 | 	body, err := io.ReadAll(authResp.Body)
362 | 	if err != nil {
363 | 		return nil, err
364 | 	}
365 | 
366 | 	respJson, err := simplejson.NewJson(body)
367 | 	if err != nil {
368 | 		return nil, err
369 | 	}
370 | 
371 | 	accessToken := respJson.Get("access_token").MustString()
372 | 	accessTokenExpAt := respJson.Get("expires_at").MustInt64()
373 | 	accessTokenExpIn := time.Until(time.Unix(accessTokenExpAt, 0))
374 | 	refreshTokenNew := respJson.Get("refresh_token").MustString()
375 | 
376 | 	ds.cache.SetWithExpiration("accessToken", accessToken, accessTokenExpIn)
377 | 	if refreshTokenNew != refreshToken {
378 | 		ds.logger.Debug("Got new refresh token")
379 | 
380 | 		err := ds.SaveRefreshToken(refreshToken)
381 | 		if err != nil {
382 | 			ds.logger.Error("Error saving refresh token", "err", err)
383 | 		}
384 | 	}
385 | 
386 | 	return &TokenExchangeResponse{
387 | 		AccessToken:      accessToken,
388 | 		AccessTokenExpAt: accessTokenExpAt,
389 | 		RefreshToken:     refreshTokenNew,
390 | 	}, nil
391 | }
392 | 
393 | func (ds *StravaDatasourceInstance) ResetAccessToken() error {
394 | 	ds.cache.Delete("accessToken")
395 | 	ds.logger.Debug("Access token removed from cache")
396 | 	return nil
397 | }
398 | 
399 | func (ds *StravaDatasourceInstance) ResetCache() {
400 | 	ds.cache.Flush()
401 | 	ds.logger.Info("Cache has been reset", "data source", ds.dsInfo.Name)
402 | }
403 | 
404 | func (ds *StravaDatasourceInstance) StravaAPIQueryWithCache(requestHash string) func(context.Context, *StravaAPIRequest) (*StravaApiResourceResponse, error) {
405 | 	cachedEndpointsPattern := regexp.MustCompile(`activities/\d+|athlete|segments/\d`)
406 | 	return func(ctx context.Context, query *StravaAPIRequest) (*StravaApiResourceResponse, error) {
407 | 		if cachedEndpointsPattern.MatchString(query.Endpoint) || query.Endpoint == "athlete/activities" {
408 | 			cachedResponse, found := ds.cache.Get(requestHash)
409 | 			if found {
410 | 				apiResponse, ok := cachedResponse.(*StravaApiResourceResponse)
411 | 				if ok {
412 | 					return apiResponse, nil
413 | 				} else {
414 | 					ds.logger.Error("Cannot get value from cache, type assertion failed")
415 | 				}
416 | 			}
417 | 			response, err := ds.StravaAPIQuery(ctx, query)
418 | 			if err != nil {
419 | 				return nil, err
420 | 			}
421 | 			if query.Endpoint == "athlete/activities" {
422 | 				ds.cache.Set(requestHash, response)
423 | 			} else {
424 | 				ds.cache.Set(requestHash, response)
425 | 			}
426 | 			return response, nil
427 | 		} else {
428 | 			return ds.StravaAPIQuery(ctx, query)
429 | 		}
430 | 	}
431 | }
432 | 
433 | func (ds *StravaDatasourceInstance) StravaAPIQuery(ctx context.Context, query *StravaAPIRequest) (*StravaApiResourceResponse, error) {
434 | 	accessToken := ""
435 | 	var err error
436 | 	if query.AccessToken == "" {
437 | 		accessToken, err = ds.GetAccessToken()
438 | 		if err != nil {
439 | 			return nil, err
440 | 		}
441 | 	} else {
442 | 		accessToken = query.AccessToken
443 | 	}
444 | 
445 | 	endpoint := query.Endpoint
446 | 	params := query.Params
447 | 
448 | 	requestUrlStr := fmt.Sprintf("%s/%s", StravaAPIUrl, strings.TrimLeft(endpoint, "/"))
449 | 	requestUrl, err := url.Parse(requestUrlStr)
450 | 	if err != nil {
451 | 		return nil, err
452 | 	}
453 | 
454 | 	q := requestUrl.Query()
455 | 	for param, value := range params {
456 | 		valueUnquoted, err := strconv.Unquote(string(value))
457 | 		if err != nil {
458 | 			valueUnquoted = string(value)
459 | 		}
460 | 		q.Add(param, valueUnquoted)
461 | 	}
462 | 	requestUrl.RawQuery = q.Encode()
463 | 	ds.logger.Debug("Strava API query", "url", requestUrl.String())
464 | 
465 | 	req := &http.Request{
466 | 		Method: "GET",
467 | 		URL:    requestUrl,
468 | 		Header: map[string][]string{
469 | 			"Authorization": {"Bearer " + accessToken},
470 | 		},
471 | 	}
472 | 
473 | 	apiResponse, err := makeHTTPRequest(ctx, ds.httpClient, req)
474 | 	if err != nil {
475 | 		return nil, err
476 | 	}
477 | 
478 | 	return BuildAPIResponse(apiResponse)
479 | }
480 | 
481 | func BuildAPIResponse(apiResponse []byte) (*StravaApiResourceResponse, error) {
482 | 	resultJson, err := simplejson.NewJson(apiResponse)
483 | 	if err != nil {
484 | 		return nil, err
485 | 	}
486 | 
487 | 	result := resultJson.Interface()
488 | 	return &StravaApiResourceResponse{
489 | 		Result: result,
490 | 	}, nil
491 | }
492 | 
493 | func makeHTTPRequest(ctx context.Context, httpClient *http.Client, req *http.Request) ([]byte, error) {
494 | 	res, err := ctxhttp.Do(ctx, httpClient, req)
495 | 	if err != nil {
496 | 		return nil, err
497 | 	}
498 | 	defer res.Body.Close()
499 | 	body, err := io.ReadAll(res.Body)
500 | 
501 | 	if res.StatusCode >= 400 {
502 | 		return body, fmt.Errorf("Error status: %v", res.Status)
503 | 	}
504 | 
505 | 	if err != nil {
506 | 		return nil, err
507 | 	}
508 | 	return body, nil
509 | }
510 | 


--------------------------------------------------------------------------------
/pkg/datasource/dscache.go:
--------------------------------------------------------------------------------
  1 | package datasource
  2 | 
  3 | import (
  4 | 	"crypto/sha1"
  5 | 	"encoding/hex"
  6 | 	"encoding/json"
  7 | 	"fmt"
  8 | 	"os"
  9 | 	"path/filepath"
 10 | 	"time"
 11 | 
 12 | 	hclog "github.com/hashicorp/go-hclog"
 13 | 	cache "github.com/patrickmn/go-cache"
 14 | 
 15 | 	"github.com/grafana/grafana-plugin-sdk-go/backend"
 16 | )
 17 | 
 18 | var cacheLogger = hclog.New(&hclog.LoggerOptions{
 19 | 	Name:  "strava-ds-cache",
 20 | 	Level: hclog.LevelFromString("DEBUG"),
 21 | })
 22 | 
 23 | // DSCache is a abstraction over go-cache.
 24 | type DSCache struct {
 25 | 	dsInfo  *backend.DataSourceInstanceSettings
 26 | 	gocache *cache.Cache
 27 | 	dataDir string
 28 | }
 29 | 
 30 | // NewDSCache creates a go-cache with expiration(ttl) time and cleanupInterval.
 31 | func NewDSCache(dsInfo *backend.DataSourceInstanceSettings, ttl time.Duration, cleanupInterval time.Duration, dataDir string) *DSCache {
 32 | 	return &DSCache{
 33 | 		dsInfo,
 34 | 		cache.New(ttl, cleanupInterval),
 35 | 		dataDir,
 36 | 	}
 37 | }
 38 | 
 39 | // Add an item to the cache with default expiration time, replacing any existing item.
 40 | func (c *DSCache) Set(request string, response interface{}) {
 41 | 	c.gocache.SetDefault(request, response)
 42 | }
 43 | 
 44 | // Save item to the cache with provided expiration time
 45 | func (c *DSCache) SetWithExpiration(request string, response interface{}, d time.Duration) {
 46 | 	c.gocache.Set(request, response, d)
 47 | }
 48 | 
 49 | // Save item to the cache with no expiration
 50 | func (c *DSCache) SetWithNoExpiration(request string, response interface{}) {
 51 | 	c.gocache.Set(request, response, cache.NoExpiration)
 52 | }
 53 | 
 54 | // Set the value of the key "request" to "response" with default expiration time.
 55 | func (c *DSCache) SetDefault(request string, response interface{}) {
 56 | 	c.gocache.SetDefault(request, response)
 57 | }
 58 | 
 59 | // Get the value associated with request from the cache
 60 | func (c *DSCache) Get(request string) (interface{}, bool) {
 61 | 	return c.gocache.Get(request)
 62 | }
 63 | 
 64 | // Remove item from cache
 65 | func (c *DSCache) Delete(request string) {
 66 | 	c.gocache.Delete(request)
 67 | }
 68 | 
 69 | // Delete all items from the cache.
 70 | func (c *DSCache) Flush() {
 71 | 	c.gocache.Flush()
 72 | }
 73 | 
 74 | // Save value to disk
 75 | func (c *DSCache) Save(request string, response interface{}) error {
 76 | 	cacheKey := c.buildDSCacheKey(request)
 77 | 	filename := filepath.Join(c.dataDir, cacheKey)
 78 | 	cacheLogger.Debug("Saving key to file", "key", request, "path", filename)
 79 | 	err := os.WriteFile(filename, []byte(response.(string)), 0644)
 80 | 	if err != nil {
 81 | 		cacheLogger.Error("Error saving data, switching to default directory", "dir", c.dataDir, "error", err)
 82 | 		c.dataDir = ""
 83 | 		return os.WriteFile(filepath.Join(c.dataDir, cacheKey), []byte(response.(string)), 0644)
 84 | 	}
 85 | 	return nil
 86 | }
 87 | 
 88 | // Load value from disk
 89 | func (c *DSCache) Load(request string) (string, error) {
 90 | 	cacheKey := c.buildDSCacheKey(request)
 91 | 	filename := filepath.Join(c.dataDir, cacheKey)
 92 | 	cacheLogger.Debug("Loading key from file", "key", request, "path", filename)
 93 | 	value, err := os.ReadFile(filename)
 94 | 	if err != nil {
 95 | 		return "", err
 96 | 	}
 97 | 	response := string(value)
 98 | 	c.SetWithExpiration(request, response, cache.NoExpiration)
 99 | 	return response, nil
100 | }
101 | 
102 | func (c *DSCache) buildDSCacheKey(request string) string {
103 | 	return fmt.Sprintf("%v-%s", c.dsInfo.ID, request)
104 | }
105 | 
106 | // HashString converts the given text string to hash string
107 | func HashString(text string) string {
108 | 	return HashByte([]byte(text))
109 | }
110 | 
111 | // HashByte converts the given bytes to hash string
112 | func HashByte(data []byte) string {
113 | 	hash := sha1.New()
114 | 	hash.Write(data)
115 | 	return hex.EncodeToString(hash.Sum(nil))
116 | }
117 | 
118 | // HashDatasourceInfo converts the given datasource info to hash string
119 | func HashDatasourceInfo(dsInfo *backend.DataSourceInstanceSettings) string {
120 | 	digester := sha1.New()
121 | 	dsInfoUniq := map[string]interface{}{
122 | 		"Id": dsInfo.ID,
123 | 		// "OrgId": dsInfo.,
124 | 	}
125 | 	if err := json.NewEncoder(digester).Encode(dsInfoUniq); err != nil {
126 | 		panic(err) // This shouldn't be possible but just in case DatasourceInfo changes
127 | 	}
128 | 	return hex.EncodeToString(digester.Sum(nil))
129 | }
130 | 


--------------------------------------------------------------------------------
/pkg/datasource/models.go:
--------------------------------------------------------------------------------
 1 | package datasource
 2 | 
 3 | import (
 4 | 	"encoding/json"
 5 | 	"fmt"
 6 | 
 7 | 	"github.com/grafana/grafana-plugin-sdk-go/backend"
 8 | )
 9 | 
10 | type StravaAPIRequest struct {
11 | 	Endpoint    string                     `json:"endpoint"`
12 | 	Params      map[string]json.RawMessage `json:"params,omitempty"`
13 | 	AccessToken string
14 | }
15 | 
16 | type StravaApiResourceResponse struct {
17 | 	Result interface{} `json:"result,omitempty"`
18 | }
19 | 
20 | type StravaAuthRequest struct {
21 | 	AuthCode string `json:"authCode"`
22 | }
23 | 
24 | type StravaAuthResourceResponse struct {
25 | 	Result interface{} `json:"result,omitempty"`
26 | }
27 | 
28 | type TokenExchangeResponse struct {
29 | 	AccessToken      string `json:"access_token"`
30 | 	AccessTokenExpAt int64  `json:"expires_at"`
31 | 	RefreshToken     string `json:"refresh_token"`
32 | }
33 | 
34 | // QueryModel model
35 | type QueryModel struct {
36 | 	QueryType    string `json:"queryType"`
37 | 	ActivityStat string `json:"activityStat"`
38 | 	ActivityType string `json:"activityType"`
39 | 	Format       string `json:"format"`
40 | 	Interval     string `json:"interval"`
41 | 
42 | 	// Direct from the gRPC interfaces
43 | 	TimeRange backend.TimeRange `json:"-"`
44 | }
45 | 
46 | // ReadQuery will read and validate Settings from the DataSourceConfig
47 | func ReadQuery(query backend.DataQuery) (QueryModel, error) {
48 | 	model := QueryModel{}
49 | 	if err := json.Unmarshal(query.JSON, &model); err != nil {
50 | 		return model, fmt.Errorf("could not read query: %w", err)
51 | 	}
52 | 
53 | 	model.TimeRange = query.TimeRange
54 | 	return model, nil
55 | }
56 | 
57 | type StravaDatasourceSettingsDTO struct {
58 | 	ClientID string `json:"clientID"`
59 | 	CacheTTL string `json:"cacheTTL"`
60 | }
61 | 
62 | type ActivityDTO = struct {
63 | 	Id int64 `json:"id"`
64 | }
65 | 


--------------------------------------------------------------------------------
/pkg/datasource/prefetcher.go:
--------------------------------------------------------------------------------
  1 | package datasource
  2 | 
  3 | import (
  4 | 	"context"
  5 | 	"encoding/json"
  6 | 	"fmt"
  7 | 
  8 | 	"github.com/grafana/grafana-plugin-sdk-go/backend/log"
  9 | )
 10 | 
 11 | const MaxTasks = 4
 12 | 
 13 | type StravaPrefetcher struct {
 14 | 	depth      int
 15 | 	cache      *DSCache
 16 | 	ds         *StravaDatasourceInstance
 17 | 	activities []string
 18 | }
 19 | 
 20 | func NewStravaPrefetcher(depth int, ds *StravaDatasourceInstance) *StravaPrefetcher {
 21 | 	return &StravaPrefetcher{
 22 | 		depth:      depth,
 23 | 		cache:      ds.cache,
 24 | 		ds:         ds,
 25 | 		activities: []string{},
 26 | 	}
 27 | }
 28 | 
 29 | // Run starts background prefetcher task
 30 | func (p *StravaPrefetcher) Run() {
 31 | 	log.DefaultLogger.Info("Starting background prefetcher")
 32 | 
 33 | 	activities, err := p.GetActivities()
 34 | 	if err != nil {
 35 | 		log.DefaultLogger.Error("Error fetching activities", "error", err)
 36 | 		return
 37 | 	}
 38 | 
 39 | 	p.PrefetchActivitiesVariable(10)
 40 | 	p.PrefetchActivitiesVariable(100)
 41 | 	p.PrefetchActivities(activities)
 42 | }
 43 | 
 44 | func (p *StravaPrefetcher) GetActivities() ([]string, error) {
 45 | 	query := &StravaAPIRequest{
 46 | 		Endpoint: "athlete/activities",
 47 | 		Params: map[string]json.RawMessage{
 48 | 			"per_page": []byte(fmt.Sprintf("%d", p.depth)),
 49 | 		},
 50 | 	}
 51 | 	resp, err := p.ds.StravaAPIQuery(context.Background(), query)
 52 | 	if err != nil {
 53 | 		return nil, fmt.Errorf("error fetching activities: %w", err)
 54 | 	}
 55 | 	activitiesRaw, ok := resp.Result.([]interface{})
 56 | 	if !ok {
 57 | 		return nil, fmt.Errorf("error parsing activities")
 58 | 	}
 59 | 	activities := make([]string, 0)
 60 | 	for _, a := range activitiesRaw {
 61 | 		activity, ok := a.(map[string]interface{})
 62 | 		if !ok {
 63 | 			return nil, fmt.Errorf("error parsing activity")
 64 | 		}
 65 | 		activityIdRaw := activity["id"]
 66 | 		activityId := activityIdRaw.(json.Number).String()
 67 | 		activities = append(activities, activityId)
 68 | 	}
 69 | 	return activities, nil
 70 | }
 71 | 
 72 | func (p *StravaPrefetcher) PrefetchActivities(activities []string) {
 73 | 	log.DefaultLogger.Debug("Prefetching activities", "activities", len(activities))
 74 | 	queue := make(chan int, MaxTasks)
 75 | 	for i := 0; i < p.depth; i++ {
 76 | 		activityId := activities[i]
 77 | 		queue <- 1
 78 | 		go func(activityId string) {
 79 | 			p.PrefetchActivity(activityId)
 80 | 			p.PrefetchActivityStreams(activityId)
 81 | 			<-queue
 82 | 		}(activityId)
 83 | 	}
 84 | }
 85 | 
 86 | func (p *StravaPrefetcher) PrefetchActivity(activityId string) {
 87 | 	payloadPattern := `{"datasourceId":%d,"endpoint":"/activities/%s","params":{"include_all_efforts":true}}`
 88 | 	payload := fmt.Sprintf(payloadPattern, p.ds.dsInfo.ID, activityId)
 89 | 
 90 | 	requestHash := HashString(payload)
 91 | 	stravaApiQueryFn := p.ds.StravaAPIQueryWithCache(requestHash)
 92 | 	apiReq := &StravaAPIRequest{
 93 | 		Endpoint: fmt.Sprintf("/activities/%s", activityId),
 94 | 		Params: map[string]json.RawMessage{
 95 | 			"include_all_efforts": []byte("true"),
 96 | 		},
 97 | 	}
 98 | 	_, err := stravaApiQueryFn(context.Background(), apiReq)
 99 | 	if err != nil {
100 | 		log.DefaultLogger.Error("Error loading activity", "error", err)
101 | 	}
102 | }
103 | 
104 | type PrefetchStreamTask struct {
105 | 	pattern string
106 | 	keys    map[string]json.RawMessage
107 | }
108 | 
109 | func (p *StravaPrefetcher) PrefetchActivityStreams(activityId string) {
110 | 	prefetchTasks := []PrefetchStreamTask{
111 | 		{
112 | 			pattern: `{"datasourceId":%d,"endpoint":"/activities/%s/streams","params":{"key_by_type":true,"keys":"velocity_smooth,time"}}`,
113 | 			keys: map[string]json.RawMessage{
114 | 				"key_by_type": []byte("true"),
115 | 				"keys":        []byte("velocity_smooth,time"),
116 | 			},
117 | 		},
118 | 		{
119 | 			pattern: `{"datasourceId":%d,"endpoint":"/activities/%s/streams","params":{"key_by_type":true,"keys":"heartrate,time"}}`,
120 | 			keys: map[string]json.RawMessage{
121 | 				"key_by_type": []byte("true"),
122 | 				"keys":        []byte("heartrate,time"),
123 | 			},
124 | 		},
125 | 		{
126 | 			pattern: `{"datasourceId":%d,"endpoint":"/activities/%s/streams","params":{"key_by_type":true,"keys":"latlng,time"}}`,
127 | 			keys: map[string]json.RawMessage{
128 | 				"key_by_type": []byte("true"),
129 | 				"keys":        []byte("latlng,time"),
130 | 			},
131 | 		},
132 | 	}
133 | 
134 | 	for _, task := range prefetchTasks {
135 | 		payload := fmt.Sprintf(task.pattern, p.ds.dsInfo.ID, activityId)
136 | 
137 | 		requestHash := HashString(payload)
138 | 		stravaApiQueryFn := p.ds.StravaAPIQueryWithCache(requestHash)
139 | 		apiReq := &StravaAPIRequest{
140 | 			Endpoint: fmt.Sprintf("/activities/%s/streams", activityId),
141 | 			Params:   task.keys,
142 | 		}
143 | 		_, err := stravaApiQueryFn(context.Background(), apiReq)
144 | 		if err != nil {
145 | 			log.DefaultLogger.Error("Error loading activity", "error", err)
146 | 		}
147 | 	}
148 | }
149 | 
150 | func (p *StravaPrefetcher) PrefetchActivitiesVariable(limit int) {
151 | 	log.DefaultLogger.Debug("Prefetching variables", "limit", limit)
152 | 	payloadPattern := `{"datasourceId":%d,"endpoint":"athlete/activities","params":{"limit":%d,"per_page":%d,"page":1}}`
153 | 	payload := fmt.Sprintf(payloadPattern, p.ds.dsInfo.ID, limit, limit)
154 | 
155 | 	requestHash := HashString(payload)
156 | 	stravaApiQueryFn := p.ds.StravaAPIQueryWithCache(requestHash)
157 | 	apiReq := &StravaAPIRequest{
158 | 		Endpoint: "athlete/activities",
159 | 		Params: map[string]json.RawMessage{
160 | 			"limit":    []byte(fmt.Sprintf("%d", limit)),
161 | 			"per_page": []byte(fmt.Sprintf("%d", limit)),
162 | 			"page":     []byte("1"),
163 | 		},
164 | 	}
165 | 	_, err := stravaApiQueryFn(context.Background(), apiReq)
166 | 	if err != nil {
167 | 		log.DefaultLogger.Error("Error loading activities", "error", err)
168 | 	}
169 | }
170 | 


--------------------------------------------------------------------------------
/pkg/datasource/resource_handler.go:
--------------------------------------------------------------------------------
  1 | package datasource
  2 | 
  3 | import (
  4 | 	"encoding/json"
  5 | 	"io"
  6 | 	"net/http"
  7 | 	"strings"
  8 | 
  9 | 	simplejson "github.com/bitly/go-simplejson"
 10 | 
 11 | 	"github.com/grafana/grafana-plugin-sdk-go/backend"
 12 | 	"github.com/grafana/grafana-plugin-sdk-go/backend/log"
 13 | )
 14 | 
 15 | // Resource handler describes handlers for the resources populated by plugin in plugin.go, like:
 16 | // mux.HandleFunc("/", ds.RootHandler)
 17 | // mux.HandleFunc("/strava-api", ds.StravaAPIHandler)
 18 | 
 19 | func (ds *StravaDatasourcePlugin) RootHandler(rw http.ResponseWriter, req *http.Request) {
 20 | 	ds.logger.Debug("Received resource call", "url", req.URL.String(), "method", req.Method)
 21 | 
 22 | 	_, err := rw.Write([]byte("Hello from Strava data source!"))
 23 | 	if err != nil {
 24 | 		ds.logger.Warn("Error writing response")
 25 | 	}
 26 | 	rw.WriteHeader(http.StatusOK)
 27 | }
 28 | 
 29 | func (ds *StravaDatasourcePlugin) StravaAuthHandler(rw http.ResponseWriter, req *http.Request) {
 30 | 	if req.Method != http.MethodPost {
 31 | 		return
 32 | 	}
 33 | 
 34 | 	body, err := io.ReadAll(req.Body)
 35 | 	defer req.Body.Close()
 36 | 	if err != nil || len(body) == 0 {
 37 | 		writeError(rw, http.StatusBadRequest, err)
 38 | 		return
 39 | 	}
 40 | 
 41 | 	var reqData StravaAuthRequest
 42 | 	err = json.Unmarshal(body, &reqData)
 43 | 	if err != nil {
 44 | 		ds.logger.Error("Cannot unmarshal request", "error", err.Error())
 45 | 		writeError(rw, http.StatusInternalServerError, err)
 46 | 		return
 47 | 	}
 48 | 
 49 | 	pluginCxt := backend.PluginConfigFromContext(req.Context())
 50 | 	dsInstance, err := ds.getDSInstance(req.Context(), pluginCxt)
 51 | 	if err != nil {
 52 | 		ds.logger.Error("Error loading datasource", "error", err)
 53 | 		writeError(rw, http.StatusInternalServerError, err)
 54 | 		return
 55 | 	}
 56 | 
 57 | 	result, err := dsInstance.StravaAuthQuery(req.Context(), &reqData)
 58 | 	if err != nil {
 59 | 		ds.logger.Error("Strava API request error", "error", err)
 60 | 		writeError(rw, http.StatusInternalServerError, err)
 61 | 		return
 62 | 	}
 63 | 
 64 | 	writeAuthResponse(rw, result)
 65 | }
 66 | 
 67 | func (ds *StravaDatasourcePlugin) ResetAccessTokenHandler(rw http.ResponseWriter, req *http.Request) {
 68 | 	pluginCxt := backend.PluginConfigFromContext(req.Context())
 69 | 	dsInstance, err := ds.getDSInstance(req.Context(), pluginCxt)
 70 | 	if err != nil {
 71 | 		ds.logger.Error("Error loading datasource", "error", err)
 72 | 		writeError(rw, http.StatusInternalServerError, err)
 73 | 		return
 74 | 	}
 75 | 
 76 | 	err = dsInstance.ResetAccessToken()
 77 | 	if err != nil {
 78 | 		ds.logger.Error("Error resetting access token", "error", err)
 79 | 		writeError(rw, http.StatusInternalServerError, err)
 80 | 		return
 81 | 	}
 82 | 
 83 | 	data := make(map[string]interface{})
 84 | 	data["message"] = "Access token removed"
 85 | 	var b []byte
 86 | 	if b, err = json.Marshal(data); err != nil {
 87 | 		rw.WriteHeader(http.StatusOK)
 88 | 		return
 89 | 	}
 90 | 
 91 | 	rw.Header().Add("Content-Type", "application/json")
 92 | 	rw.WriteHeader(http.StatusOK)
 93 | 	_, err = rw.Write(b)
 94 | 	if err != nil {
 95 | 		ds.logger.Warn("Error writing response")
 96 | 	}
 97 | }
 98 | 
 99 | func (ds *StravaDatasourcePlugin) ResetCacheHandler(rw http.ResponseWriter, req *http.Request) {
100 | 	pluginCxt := backend.PluginConfigFromContext(req.Context())
101 | 	dsInstance, err := ds.getDSInstance(req.Context(), pluginCxt)
102 | 	if err != nil {
103 | 		ds.logger.Error("Error loading datasource", "error", err)
104 | 		writeError(rw, http.StatusInternalServerError, err)
105 | 		return
106 | 	}
107 | 
108 | 	dsInstance.ResetCache()
109 | 
110 | 	data := make(map[string]interface{})
111 | 	data["message"] = "Cache flushed"
112 | 	var b []byte
113 | 	if b, err = json.Marshal(data); err != nil {
114 | 		rw.WriteHeader(http.StatusOK)
115 | 		return
116 | 	}
117 | 
118 | 	rw.Header().Add("Content-Type", "application/json")
119 | 	rw.WriteHeader(http.StatusOK)
120 | 	_, err = rw.Write(b)
121 | 	if err != nil {
122 | 		ds.logger.Warn("Error writing response")
123 | 	}
124 | }
125 | 
126 | func (ds *StravaDatasourcePlugin) StravaAPIHandler(rw http.ResponseWriter, req *http.Request) {
127 | 	if req.Method != http.MethodPost {
128 | 		return
129 | 	}
130 | 
131 | 	body, err := io.ReadAll(req.Body)
132 | 	defer req.Body.Close()
133 | 	if err != nil || len(body) == 0 {
134 | 		writeError(rw, http.StatusBadRequest, err)
135 | 		return
136 | 	}
137 | 
138 | 	var apiReq StravaAPIRequest
139 | 	err = json.Unmarshal(body, &apiReq)
140 | 	if err != nil {
141 | 		ds.logger.Error("Cannot unmarshal request", "error", err.Error())
142 | 		writeError(rw, http.StatusInternalServerError, err)
143 | 		return
144 | 	}
145 | 
146 | 	pluginCxt := backend.PluginConfigFromContext(req.Context())
147 | 	dsInstance, err := ds.getDSInstance(req.Context(), pluginCxt)
148 | 	if err != nil {
149 | 		ds.logger.Error("Error loading datasource", "error", err)
150 | 		writeError(rw, http.StatusInternalServerError, err)
151 | 		return
152 | 	}
153 | 
154 | 	oauthPassThru := isOAuthPassThruEnabled(dsInstance)
155 | 	if oauthPassThru {
156 | 		accessToken := ""
157 | 		if len(req.Header["Authorization"]) > 0 {
158 | 			authorizationStr := req.Header["Authorization"][0]
159 | 			values := strings.Split(authorizationStr, " ")
160 | 			if len(values) > 1 {
161 | 				accessToken = values[1]
162 | 			}
163 | 		}
164 | 		apiReq.AccessToken = accessToken
165 | 	}
166 | 
167 | 	requestHash := HashByte(body)
168 | 	stravaApiQueryFn := dsInstance.StravaAPIQueryWithCache(requestHash)
169 | 	result, err := stravaApiQueryFn(req.Context(), &apiReq)
170 | 	if err != nil {
171 | 		ds.logger.Error("Strava API request error", "error", err)
172 | 		writeError(rw, http.StatusInternalServerError, err)
173 | 		return
174 | 	}
175 | 
176 | 	writeApiResponse(rw, result)
177 | }
178 | 
179 | func writeApiResponse(rw http.ResponseWriter, result *StravaApiResourceResponse) {
180 | 	resultJson, err := json.Marshal(*result)
181 | 	if err != nil {
182 | 		writeError(rw, http.StatusInternalServerError, err)
183 | 	}
184 | 
185 | 	writeResponse(rw, resultJson)
186 | }
187 | 
188 | func writeAuthResponse(rw http.ResponseWriter, result *StravaAuthResourceResponse) {
189 | 	resultJson, err := json.Marshal(*result)
190 | 	if err != nil {
191 | 		writeError(rw, http.StatusInternalServerError, err)
192 | 	}
193 | 
194 | 	writeResponse(rw, resultJson)
195 | }
196 | 
197 | func writeResponse(rw http.ResponseWriter, resultJson []byte) {
198 | 	rw.Header().Add("Content-Type", "application/json")
199 | 	rw.WriteHeader(http.StatusOK)
200 | 	_, err := rw.Write(resultJson)
201 | 	if err != nil {
202 | 		log.DefaultLogger.Warn("Error writing response")
203 | 	}
204 | }
205 | 
206 | func writeError(rw http.ResponseWriter, statusCode int, err error) {
207 | 	data := make(map[string]interface{})
208 | 
209 | 	data["error"] = "Internal Server Error"
210 | 	data["message"] = err.Error()
211 | 
212 | 	var b []byte
213 | 	if b, err = json.Marshal(data); err != nil {
214 | 		rw.WriteHeader(statusCode)
215 | 		return
216 | 	}
217 | 
218 | 	rw.Header().Add("Content-Type", "application/json")
219 | 	rw.WriteHeader(http.StatusInternalServerError)
220 | 	_, err = rw.Write(b)
221 | 	if err != nil {
222 | 		log.DefaultLogger.Warn("Error writing response")
223 | 	}
224 | }
225 | 
226 | func isOAuthPassThruEnabled(dsInstance *StravaDatasourceInstance) bool {
227 | 	jsonDataStr := dsInstance.dsInfo.JSONData
228 | 	jsonData, err := simplejson.NewJson([]byte(jsonDataStr))
229 | 	if err != nil {
230 | 		return false
231 | 	}
232 | 	return jsonData.Get("oauthPassThru").MustBool()
233 | }
234 | 


--------------------------------------------------------------------------------
/pkg/grafanaclient/client.go:
--------------------------------------------------------------------------------
 1 | package grafanaclient
 2 | 
 3 | import (
 4 | 	"context"
 5 | 	"fmt"
 6 | 	"io"
 7 | 	"net/http"
 8 | 	"os"
 9 | 	"strings"
10 | 
11 | 	"github.com/grafana/grafana-plugin-sdk-go/backend"
12 | 	"github.com/grafana/grafana-plugin-sdk-go/backend/httpclient"
13 | 	"github.com/grafana/grafana-plugin-sdk-go/backend/log"
14 | )
15 | 
16 | type GrafanaHTTPClient interface {
17 | 	DoRequest(method string, url string, body io.Reader) (*http.Response, error)
18 | 	Get(url string) (*http.Response, error)
19 | }
20 | 
21 | type grafanaHTTPClient struct {
22 | 	appURL     string
23 | 	httpClient *http.Client
24 | }
25 | 
26 | func NewGrafanaHTTPClient(ctx context.Context, settings backend.DataSourceInstanceSettings, saToken string) (*grafanaHTTPClient, error) {
27 | 	grafanaAppURL := strings.TrimRight(os.Getenv("GF_APP_URL"), "/")
28 | 	if grafanaAppURL == "" {
29 | 		grafanaAppURL = "http://localhost:3000"
30 | 		log.DefaultLogger.Debug("URL is empty, set default one", "url", grafanaAppURL)
31 | 	}
32 | 	log.DefaultLogger.Debug("Grafana App URL", "url", grafanaAppURL)
33 | 
34 | 	opts, err := settings.HTTPClientOptions(ctx)
35 | 	if err != nil {
36 | 		return nil, fmt.Errorf("error getting http client options: %w", err)
37 | 	}
38 | 
39 | 	opts.Header = http.Header{
40 | 		"Authorization": []string{"Bearer " + saToken},
41 | 		"Content-Type":  []string{"application/json"},
42 | 	}
43 | 
44 | 	httpClient, err := httpclient.New(opts)
45 | 	if err != nil {
46 | 		return nil, fmt.Errorf("error creating new http client: %w", err)
47 | 	}
48 | 
49 | 	client := &grafanaHTTPClient{
50 | 		appURL:     grafanaAppURL,
51 | 		httpClient: httpClient,
52 | 	}
53 | 
54 | 	return client, nil
55 | }
56 | 
57 | func (c grafanaHTTPClient) DoRequest(method string, url string, body io.Reader) (*http.Response, error) {
58 | 	url = strings.TrimLeft(url, "/")
59 | 	appURL := strings.TrimRight(c.appURL, "/")
60 | 	req, err := http.NewRequest(method, fmt.Sprintf("%s/%s", appURL, url), body)
61 | 	if err != nil {
62 | 		return nil, err
63 | 	}
64 | 	res, err := c.httpClient.Do(req)
65 | 	if err != nil {
66 | 		return nil, err
67 | 	}
68 | 	return res, nil
69 | }
70 | 
71 | func (c grafanaHTTPClient) Get(url string) (*http.Response, error) {
72 | 	return c.DoRequest("GET", url, nil)
73 | }
74 | 


--------------------------------------------------------------------------------
/pkg/plugin.go:
--------------------------------------------------------------------------------
  1 | package main
  2 | 
  3 | import (
  4 | 	"errors"
  5 | 	"net/http"
  6 | 	"os"
  7 | 	"path"
  8 | 
  9 | 	"github.com/grafana/strava-datasource/pkg/datasource"
 10 | 
 11 | 	"github.com/grafana/grafana-plugin-sdk-go/backend"
 12 | 	"github.com/grafana/grafana-plugin-sdk-go/backend/log"
 13 | 	"github.com/grafana/grafana-plugin-sdk-go/backend/resource/httpadapter"
 14 | )
 15 | 
 16 | const (
 17 | 	STRAVA_PLUGIN_ID   = "strava-backend-datasource"
 18 | 	DATA_PATH_VARIABLE = "GF_STRAVA_DS_DATA_PATH"
 19 | 	DEFAULT_DATA_DIR   = "strava-datasource"
 20 | )
 21 | 
 22 | func main() {
 23 | 	backend.SetupPluginEnvironment(STRAVA_PLUGIN_ID)
 24 | 	mux := http.NewServeMux()
 25 | 	ds := Init(mux)
 26 | 	httpResourceHandler := httpadapter.New(mux)
 27 | 
 28 | 	log.DefaultLogger.Debug("Starting Strava datasource")
 29 | 
 30 | 	err := backend.Manage(STRAVA_PLUGIN_ID, backend.ServeOpts{
 31 | 		CallResourceHandler: httpResourceHandler,
 32 | 		QueryDataHandler:    ds,
 33 | 		CheckHealthHandler:  ds,
 34 | 	})
 35 | 	if err != nil {
 36 | 		log.DefaultLogger.Error("Error starting Strava datasource", "error", err.Error())
 37 | 	}
 38 | }
 39 | 
 40 | func Init(mux *http.ServeMux) *datasource.StravaDatasourcePlugin {
 41 | 	dataDirPath, err := getDataDir()
 42 | 	if err != nil {
 43 | 		log.DefaultLogger.Error(err.Error())
 44 | 	} else {
 45 | 		log.DefaultLogger.Info("Data dir configured", "path", dataDirPath)
 46 | 	}
 47 | 
 48 | 	saToken := os.Getenv("GF_PLUGIN_APP_CLIENT_SECRET")
 49 | 	if saToken == "" {
 50 | 		log.DefaultLogger.Error("GF_PLUGIN_APP_CLIENT_SECRET is required")
 51 | 	}
 52 | 
 53 | 	ds := datasource.NewStravaDatasourcePlugin(dataDirPath, saToken)
 54 | 
 55 | 	mux.HandleFunc("/", ds.RootHandler)
 56 | 	mux.HandleFunc("/auth", ds.StravaAuthHandler)
 57 | 	mux.HandleFunc("/strava-api", ds.StravaAPIHandler)
 58 | 	mux.HandleFunc("/reset-access-token", ds.ResetAccessTokenHandler)
 59 | 	mux.HandleFunc("/reset-cache", ds.ResetCacheHandler)
 60 | 
 61 | 	return ds
 62 | }
 63 | 
 64 | func getDataDir() (string, error) {
 65 | 	// Return GF_STRAVA_DS_DATA_PATH value if set
 66 | 	dataDirPath, exist := os.LookupEnv(DATA_PATH_VARIABLE)
 67 | 	if exist && dataDirPath != "" {
 68 | 		log.DefaultLogger.Info("Environment variable for storage path found", "variable", DATA_PATH_VARIABLE, "value", dataDirPath)
 69 | 		return dataDirPath, nil
 70 | 	}
 71 | 	log.DefaultLogger.Debug("Could not read environment variable", "variable", DATA_PATH_VARIABLE)
 72 | 
 73 | 	dataDirOptions := make([]string, 0)
 74 | 
 75 | 	userCacheDir, err := os.UserCacheDir()
 76 | 	if err != nil {
 77 | 		log.DefaultLogger.Debug("Cannot get OS cache directory path", "error", err)
 78 | 	} else {
 79 | 		dataDirOptions = append(dataDirOptions, userCacheDir)
 80 | 	}
 81 | 
 82 | 	dataDirOptions = append(dataDirOptions, "/var/lib/grafana/data", "/var/lib/grafana")
 83 | 
 84 | 	for _, p := range dataDirOptions {
 85 | 		dataDirPath, err := checkDataDir(p)
 86 | 		if err == nil {
 87 | 			return dataDirPath, nil
 88 | 		} else {
 89 | 			log.DefaultLogger.Debug("Error checking data directory", "error", err)
 90 | 		}
 91 | 	}
 92 | 
 93 | 	return "", errors.New("Cannot get data directory")
 94 | }
 95 | 
 96 | func checkDataDir(p string) (string, error) {
 97 | 	if _, err := os.Stat(p); err != nil {
 98 | 		return "", err
 99 | 	}
100 | 	dataDirPath := path.Join(p, DEFAULT_DATA_DIR)
101 | 	err := os.MkdirAll(dataDirPath, os.ModePerm)
102 | 	if err != nil {
103 | 		return "", err
104 | 	}
105 | 	return dataDirPath, nil
106 | }
107 | 


--------------------------------------------------------------------------------
/setup_tests.ts:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/grafana/strava-datasource/f662a4d133b862dc5cf78804ba16352846461110/setup_tests.ts


--------------------------------------------------------------------------------
/src/components/AthleteLabel.tsx:
--------------------------------------------------------------------------------
 1 | import React, { FC } from 'react';
 2 | import { css, cx } from '@emotion/css';
 3 | import { InlineFormLabel, Spinner, stylesFactory, useTheme } from '@grafana/ui';
 4 | import { GrafanaTheme } from '@grafana/data';
 5 | import { StravaAthlete } from '../types';
 6 | 
 7 | const getStyles = stylesFactory((theme: GrafanaTheme) => {
 8 |   return {
 9 |     athleteLabel: css`
10 |       height: ${theme.spacing.formInputHeight}px;
11 |       padding: 2px;
12 |       margin-right: 0px;
13 |       border-radius: ${theme.border.radius.md};
14 |       background-color: ${theme.colors.bg2};
15 |     `,
16 |     athleteAvatar: css`
17 |       height: 28px;
18 |       border-radius: 50%;
19 |     `,
20 |     athletePlaceholder: css`
21 |       width: 28px;
22 |     `,
23 |     spinner: css`
24 |       width: 28px;
25 |       height: ${theme.spacing.formInputHeight}px;
26 |       padding: 2px;
27 |       border-radius: ${theme.border.radius.md};
28 |       background-color: ${theme.palette.dark4};
29 |     `,
30 |   };
31 | });
32 | 
33 | interface Props {
34 |   athlete?: StravaAthlete;
35 |   isLoading?: boolean;
36 | }
37 | 
38 | export const AthleteLabel: FC<Props> = ({ athlete, isLoading }: Props) => {
39 |   const styles = getStyles(useTheme());
40 |   const imgClass = cx('filter-table__avatar', styles.athleteAvatar);
41 |   return isLoading ? (
42 |     <div className="gf-form">
43 |       <div className={styles.spinner}>
44 |         <Spinner size={20} />
45 |       </div>
46 |       <InlineFormLabel>&nbsp;</InlineFormLabel>
47 |     </div>
48 |   ) : (
49 |     <div className="gf-form">
50 |       {athlete?.profile_medium ? (
51 |         <div className={styles.athleteLabel}>
52 |           <img className={imgClass} src={athlete.profile_medium} />
53 |         </div>
54 |       ) : (
55 |         <div className={styles.athletePlaceholder}></div>
56 |       )}
57 |       <InlineFormLabel>
58 |         {athlete?.firstname} {athlete?.lastname}
59 |       </InlineFormLabel>
60 |     </div>
61 |   );
62 | };
63 | 


--------------------------------------------------------------------------------
/src/components/ConfigEditor.tsx:
--------------------------------------------------------------------------------
  1 | import React, { ChangeEvent, useEffect, useCallback } from 'react';
  2 | import { Button, InlineField, Input, InlineFieldRow, InlineSwitch, Alert, VerticalGroup } from '@grafana/ui';
  3 | import { DataSourcePluginOptionsEditorProps, DataSourceSettings } from '@grafana/data';
  4 | import { StravaJsonData, StravaSecureJsonData } from '../types';
  5 | 
  6 | const AuthCodePattern = /code=([\w]+)/;
  7 | 
  8 | export type Props = DataSourcePluginOptionsEditorProps<StravaJsonData, StravaSecureJsonData>;
  9 | 
 10 | type StravaSettings = DataSourceSettings<StravaJsonData, StravaSecureJsonData>;
 11 | 
 12 | export interface State {
 13 |   config: StravaSettings;
 14 | }
 15 | 
 16 | export const ConfigEditor = ({ options, onOptionsChange }: Props) => {
 17 |   const updateDatasource = useCallback(
 18 |     (config: any) => {
 19 |       for (const j in config.jsonData) {
 20 |         if (config.jsonData[j].length === 0) {
 21 |           delete config.jsonData[j];
 22 |         }
 23 |       }
 24 | 
 25 |       for (const k in config.secureJsonData) {
 26 |         if (config.secureJsonData[k].length === 0) {
 27 |           delete config.secureJsonData[k];
 28 |         }
 29 |       }
 30 | 
 31 |       onOptionsChange({
 32 |         ...config,
 33 |       });
 34 |     },
 35 |     [onOptionsChange]
 36 |   );
 37 | 
 38 |   useEffect(() => {
 39 |     updateDatasource(getDefaults(options));
 40 |     // eslint-disable-next-line react-hooks/exhaustive-deps
 41 |   }, []);
 42 | 
 43 |   const onCacheTTLChange = (cacheTTL: string) => {
 44 |     onOptionsChange({
 45 |       ...options,
 46 |       jsonData: {
 47 |         ...options.jsonData,
 48 |         cacheTTL,
 49 |       },
 50 |     });
 51 |   };
 52 | 
 53 |   const onResetClientSecret = () => {
 54 |     onOptionsChange({
 55 |       ...options,
 56 |       secureJsonFields: {
 57 |         ...options.secureJsonFields,
 58 |         clientSecret: false,
 59 |       },
 60 |     });
 61 |   };
 62 | 
 63 |   const onClientIDChange = (clientID: string) => {
 64 |     onOptionsChange({
 65 |       ...options,
 66 |       jsonData: {
 67 |         ...options.jsonData,
 68 |         clientID,
 69 |       },
 70 |     });
 71 |   };
 72 | 
 73 |   const onClientSecretChange = (clientSecret: string) => {
 74 |     onOptionsChange({
 75 |       ...options,
 76 |       secureJsonData: {
 77 |         ...options.secureJsonData,
 78 |         clientSecret,
 79 |       },
 80 |     });
 81 |   };
 82 | 
 83 |   const isLocationContainsCode = () => {
 84 |     return AuthCodePattern.test(window.location.search);
 85 |   };
 86 | 
 87 |   const isLocationContainsError = () => {
 88 |     return /error=/.test(window.location.search);
 89 |   };
 90 | 
 91 |   const getConnectWithStravaHref = () => {
 92 |     const authUrl = 'https://www.strava.com/oauth/authorize';
 93 |     const currentLocation = window.location.origin + window.location.pathname;
 94 |     const clientID = options.jsonData.clientID;
 95 |     const authScope = 'read_all,profile:read_all,activity:read_all';
 96 |     return `${authUrl}?client_id=${clientID}&response_type=code&redirect_uri=${currentLocation}&approval_prompt=force&scope=${authScope}`;
 97 |   };
 98 | 
 99 |   const connectWithStravaHref = getConnectWithStravaHref();
100 |   const showConnectWithStravaButton = options.jsonData.clientID && options.secureJsonFields.clientSecret;
101 | 
102 |   return (
103 |     <>
104 |       <div className="gf-form-group">
105 |         <div className="gf-form-inline">
106 |           <InlineField
107 |             label="Forward OAuth Identity"
108 |             tooltip="Forward the user's upstream OAuth identity to the data source (Their access token gets passed along)."
109 |             labelWidth={26}
110 |           >
111 |             <InlineSwitch
112 |               id="http-settings-forward-oauth"
113 |               value={options.jsonData.oauthPassThru || false}
114 |               onChange={(event) =>
115 |                 onOptionsChange({
116 |                   ...options,
117 |                   jsonData: {
118 |                     ...options.jsonData,
119 |                     oauthPassThru: event!.currentTarget.checked,
120 |                   },
121 |                 })
122 |               }
123 |             />
124 |           </InlineField>
125 |         </div>
126 |       </div>
127 |       <h2 className="page-heading">Strava API Details</h2>
128 |       <div className="gf-form-group">
129 |         <InlineFieldRow>
130 |           <InlineField label="Client ID" labelWidth={16}>
131 |             <Input
132 |               width={50}
133 |               value={options.jsonData.clientID || ''}
134 |               onChange={(event: ChangeEvent<HTMLInputElement>) => onClientIDChange(event.target.value)}
135 |             />
136 |           </InlineField>
137 |         </InlineFieldRow>
138 |         <InlineFieldRow>
139 |           {options.secureJsonFields && options.secureJsonFields.clientSecret ? (
140 |             <>
141 |               <InlineField label="Client Secret" labelWidth={16}>
142 |                 <Input placeholder="Configured" width={50} disabled />
143 |               </InlineField>
144 |               <InlineField>
145 |                 <Button variant="secondary" type="button" onClick={onResetClientSecret}>
146 |                   Reset
147 |                 </Button>
148 |               </InlineField>
149 |             </>
150 |           ) : (
151 |             <InlineField label="Client Secret" labelWidth={16}>
152 |               <Input
153 |                 width={50}
154 |                 value={options.secureJsonData?.clientSecret || ''}
155 |                 onChange={(event: ChangeEvent<HTMLInputElement>) => onClientSecretChange(event.target.value)}
156 |               />
157 |             </InlineField>
158 |           )}
159 |         </InlineFieldRow>
160 |       </div>
161 |       <div className="gf-form-group">
162 |         <InlineFieldRow>
163 |           <InlineField
164 |             label="Cache TTL"
165 |             labelWidth={16}
166 |             tooltip="Plugin stores activities and other data in cache to improve performance and avoid API rate limits."
167 |           >
168 |             <Input
169 |               width={10}
170 |               value={options.jsonData.cacheTTL || ''}
171 |               placeholder="1h"
172 |               onChange={(event: ChangeEvent<HTMLInputElement>) => onCacheTTLChange(event.target.value)}
173 |             />
174 |           </InlineField>
175 |         </InlineFieldRow>
176 |       </div>
177 |       {showConnectWithStravaButton && (
178 |         <div className="gf-form-group">
179 |           <VerticalGroup>
180 |             <a type="button" href={connectWithStravaHref}>
181 |               <img src="public/plugins/grafana-strava-datasource/img/btn_strava_connectwith_orange.svg" />
182 |             </a>
183 |             {isLocationContainsCode() && (
184 |               <Alert severity="success" title={''}>
185 |                 Auth code successfully obtained. Save data source to finish authentication.
186 |               </Alert>
187 |             )}
188 |             {isLocationContainsError() && (
189 |               <Alert severity="error" title={''}>
190 |                 Error obtaining auth code.
191 |               </Alert>
192 |             )}
193 |           </VerticalGroup>
194 |         </div>
195 |       )}
196 |     </>
197 |   );
198 | };
199 | 
200 | function getDefaults(options: any) {
201 |   if (!options.hasOwnProperty('secureJsonData')) {
202 |     options.secureJsonData = {};
203 |   }
204 | 
205 |   if (!options.hasOwnProperty('jsonData')) {
206 |     options.jsonData = {};
207 |   }
208 | 
209 |   if (!options.hasOwnProperty('secureJsonFields')) {
210 |     options.secureJsonFields = {};
211 |   }
212 | 
213 |   return options;
214 | }
215 | 


--------------------------------------------------------------------------------
/src/components/VariableQueryEditor.tsx:
--------------------------------------------------------------------------------
  1 | import React, { PureComponent } from 'react';
  2 | import { SelectableValue } from '@grafana/data';
  3 | import { VariableQueryTypes, StravaActivityType, VariableQuery } from '../types';
  4 | import { InlineField, InlineFieldRow, InlineFormLabel, Input, Select } from '@grafana/ui';
  5 | import { DEFAULT_LIMIT } from '../datasource';
  6 | 
  7 | const stravaActivityTypeOptions: Array<SelectableValue<StravaActivityType>> = [
  8 |   { value: '', label: 'All' },
  9 |   { value: 'Run', label: 'Run' },
 10 |   { value: 'Ride', label: 'Ride' },
 11 |   { value: 'Other', label: 'Other' },
 12 | ];
 13 | 
 14 | export interface VariableQueryProps {
 15 |   query: VariableQuery;
 16 |   onChange: (query: VariableQuery, definition: string) => void;
 17 |   datasource: any;
 18 |   templateSrv: any;
 19 | }
 20 | 
 21 | interface State {
 22 |   limit: number;
 23 | }
 24 | 
 25 | export class StravaVariableQueryEditor extends PureComponent<VariableQueryProps, State> {
 26 |   constructor(props: VariableQueryProps) {
 27 |     super(props);
 28 |     const { query } = this.props;
 29 |     this.state = {
 30 |       limit: query.limit || DEFAULT_LIMIT,
 31 |     };
 32 |   }
 33 | 
 34 |   queryTypes: Array<SelectableValue<VariableQueryTypes>> = [
 35 |     { value: VariableQueryTypes.Activity, label: 'Activity' },
 36 |     { value: VariableQueryTypes.SegmentEffort, label: 'Segment effort' },
 37 |   ];
 38 | 
 39 |   onQueryTypeChange = (selectedItem: SelectableValue<VariableQueryTypes>) => {
 40 |     const queryType = selectedItem.value || VariableQueryTypes.Activity;
 41 | 
 42 |     const queryModel: VariableQuery = { ...this.props.query, queryType };
 43 |     this.props.onChange(queryModel, `Strava - ${queryType}`);
 44 |   };
 45 | 
 46 |   onActivityTypeChange = (selectedItem: SelectableValue<StravaActivityType>) => {
 47 |     const activityType = selectedItem.value || '';
 48 | 
 49 |     const queryModel: VariableQuery = { ...this.props.query, activityType };
 50 |     this.props.onChange(queryModel, `Strava - ${this.props.query.queryType}`);
 51 |   };
 52 | 
 53 |   onLimitStateChange = (e: React.SyntheticEvent<HTMLInputElement>) => {
 54 |     const limit = Number(e.currentTarget.value || '');
 55 |     this.setState({ limit });
 56 |   };
 57 | 
 58 |   onLimitChange = (e: React.SyntheticEvent<HTMLInputElement>) => {
 59 |     const limit = Number(e.currentTarget.value || '');
 60 |     const queryModel: VariableQuery = { ...this.props.query, limit };
 61 |     this.props.onChange(queryModel, `Strava - ${this.props.query.queryType}`);
 62 |   };
 63 | 
 64 |   onActivityIdChange = (e: React.SyntheticEvent<HTMLInputElement>) => {
 65 |     const activityId = e.currentTarget.value || '';
 66 |     const queryModel: VariableQuery = { ...this.props.query, activityId };
 67 |     this.props.onChange(queryModel, `Strava - ${this.props.query.queryType}`);
 68 |   };
 69 | 
 70 |   render() {
 71 |     const { query } = this.props;
 72 |     const { limit } = this.state;
 73 | 
 74 |     return (
 75 |       <>
 76 |         <div className="gf-form max-width-21">
 77 |           <InlineFormLabel width={10}>Query Type</InlineFormLabel>
 78 |           <Select width={20} value={query.queryType} options={this.queryTypes} onChange={this.onQueryTypeChange} />
 79 |         </div>
 80 |         <div className="gf-form-inline">
 81 |           {query.queryType === VariableQueryTypes.Activity && (
 82 |             <InlineFieldRow>
 83 |               <InlineField label="Activity Type" labelWidth={20}>
 84 |                 <Select
 85 |                   width={16}
 86 |                   value={query.activityType}
 87 |                   onChange={this.onActivityTypeChange}
 88 |                   options={stravaActivityTypeOptions}
 89 |                 />
 90 |               </InlineField>
 91 |               <InlineField label="Limit" labelWidth={10} tooltip="API query limit. Set to 0 for no limit.">
 92 |                 <Input
 93 |                   type="number"
 94 |                   value={limit}
 95 |                   onChange={this.onLimitStateChange}
 96 |                   onBlur={this.onLimitChange}
 97 |                   width={12}
 98 |                 />
 99 |               </InlineField>
100 |             </InlineFieldRow>
101 |           )}
102 |           {query.queryType === VariableQueryTypes.SegmentEffort && (
103 |             <InlineFieldRow>
104 |               <InlineField label="Activity" labelWidth={20} tooltip="Activity id">
105 |                 <Input
106 |                   value={query.activityId}
107 |                   onChange={this.onActivityIdChange}
108 |                   onBlur={this.onActivityIdChange}
109 |                   width={30}
110 |                 />
111 |               </InlineField>
112 |             </InlineFieldRow>
113 |           )}
114 |         </div>
115 |       </>
116 |     );
117 |   }
118 | }
119 | 


--------------------------------------------------------------------------------
/src/dashboards/strava_activity_analysis.json:
--------------------------------------------------------------------------------
  1 | {
  2 |   "__inputs": [
  3 |     {
  4 |       "name": "DS_STRAVA",
  5 |       "label": "Strava",
  6 |       "description": "",
  7 |       "type": "datasource",
  8 |       "pluginId": "grafana-strava-datasource",
  9 |       "pluginName": "Strava"
 10 |     }
 11 |   ],
 12 |   "__requires": [
 13 |     {
 14 |       "type": "grafana",
 15 |       "id": "grafana",
 16 |       "name": "Grafana",
 17 |       "version": "9.0.0"
 18 |     },
 19 |     {
 20 |       "type": "datasource",
 21 |       "id": "grafana-strava-datasource",
 22 |       "name": "Strava",
 23 |       "version": "1.2.0"
 24 |     },
 25 |     {
 26 |       "type": "panel",
 27 |       "id": "graph",
 28 |       "name": "Graph",
 29 |       "version": ""
 30 |     }
 31 |   ],
 32 |   "annotations": {
 33 |     "list": [
 34 |       {
 35 |         "builtIn": 1,
 36 |         "datasource": "-- Grafana --",
 37 |         "enable": true,
 38 |         "hide": true,
 39 |         "iconColor": "rgba(0, 211, 255, 1)",
 40 |         "name": "Annotations & Alerts",
 41 |         "type": "dashboard"
 42 |       }
 43 |     ]
 44 |   },
 45 |   "editable": true,
 46 |   "gnetId": null,
 47 |   "graphTooltip": 0,
 48 |   "id": null,
 49 |   "iteration": 1620799866184,
 50 |   "links": [],
 51 |   "panels": [
 52 |     {
 53 |       "aliasColors": {
 54 |         "heartrate": "red",
 55 |         "velocity_smooth": "blue"
 56 |       },
 57 |       "bars": false,
 58 |       "dashLength": 10,
 59 |       "dashes": false,
 60 |       "datasource": {
 61 |         "type": "grafana-strava-datasource",
 62 |         "uid": "${DS_STRAVA}"
 63 |       },
 64 |       "fieldConfig": {
 65 |         "defaults": {
 66 |           "unit": "short"
 67 |         },
 68 |         "overrides": []
 69 |       },
 70 |       "fill": 1,
 71 |       "fillGradient": 7,
 72 |       "gridPos": {
 73 |         "h": 8,
 74 |         "w": 12,
 75 |         "x": 0,
 76 |         "y": 0
 77 |       },
 78 |       "hiddenSeries": false,
 79 |       "id": 2,
 80 |       "legend": {
 81 |         "avg": false,
 82 |         "current": false,
 83 |         "max": false,
 84 |         "min": false,
 85 |         "show": false,
 86 |         "total": false,
 87 |         "values": false
 88 |       },
 89 |       "lines": true,
 90 |       "linewidth": 2,
 91 |       "nullPointMode": "null",
 92 |       "options": {
 93 |         "alertThreshold": true
 94 |       },
 95 |       "percentage": false,
 96 |       "pluginVersion": "7.5.0",
 97 |       "pointradius": 2,
 98 |       "points": false,
 99 |       "renderer": "flot",
100 |       "seriesOverrides": [
101 |         {
102 |           "$$hashKey": "object:97",
103 |           "alias": "velocity_smooth",
104 |           "fill": 0,
105 |           "fillGradient": 0,
106 |           "linewidth": 1,
107 |           "yaxis": 2
108 |         }
109 |       ],
110 |       "spaceLength": 10,
111 |       "stack": false,
112 |       "steppedLine": false,
113 |       "targets": [
114 |         {
115 |           "activityData": "graph",
116 |           "activityGraph": "heartrate",
117 |           "activityId": "$Activity",
118 |           "activityType": "Run",
119 |           "fitToTimeRange": true,
120 |           "queryType": "Activity",
121 |           "refId": "A",
122 |           "selectedActivity": {
123 |             "description": "Variable",
124 |             "label": "$Activity",
125 |             "value": "$Activity"
126 |           }
127 |         }
128 |       ],
129 |       "thresholds": [],
130 |       "timeFrom": null,
131 |       "timeRegions": [],
132 |       "timeShift": null,
133 |       "title": "Heart Rate",
134 |       "tooltip": {
135 |         "shared": true,
136 |         "sort": 0,
137 |         "value_type": "individual"
138 |       },
139 |       "type": "graph",
140 |       "xaxis": {
141 |         "buckets": null,
142 |         "mode": "time",
143 |         "name": null,
144 |         "show": true,
145 |         "values": []
146 |       },
147 |       "yaxes": [
148 |         {
149 |           "$$hashKey": "object:132",
150 |           "format": "short",
151 |           "label": null,
152 |           "logBase": 1,
153 |           "max": null,
154 |           "min": "0",
155 |           "show": true
156 |         },
157 |         {
158 |           "$$hashKey": "object:133",
159 |           "format": "short",
160 |           "label": null,
161 |           "logBase": 1,
162 |           "max": null,
163 |           "min": null,
164 |           "show": true
165 |         }
166 |       ],
167 |       "yaxis": {
168 |         "align": false,
169 |         "alignLevel": null
170 |       }
171 |     },
172 |     {
173 |       "aliasColors": {
174 |         "Afternoon Run": "red",
175 |         "average_heartrate": "red",
176 |         "heartrate": "red",
177 |         "velocity_smooth": "blue"
178 |       },
179 |       "bars": true,
180 |       "dashLength": 10,
181 |       "dashes": false,
182 |       "datasource": {
183 |         "type": "grafana-strava-datasource",
184 |         "uid": "${DS_STRAVA}"
185 |       },
186 |       "fieldConfig": {
187 |         "defaults": {
188 |           "unit": "short"
189 |         },
190 |         "overrides": []
191 |       },
192 |       "fill": 1,
193 |       "fillGradient": 7,
194 |       "gridPos": {
195 |         "h": 8,
196 |         "w": 12,
197 |         "x": 12,
198 |         "y": 0
199 |       },
200 |       "hiddenSeries": false,
201 |       "id": 7,
202 |       "legend": {
203 |         "avg": false,
204 |         "current": false,
205 |         "max": false,
206 |         "min": false,
207 |         "show": false,
208 |         "total": false,
209 |         "values": false
210 |       },
211 |       "lines": false,
212 |       "linewidth": 2,
213 |       "nullPointMode": "null",
214 |       "options": {
215 |         "alertThreshold": false
216 |       },
217 |       "percentage": false,
218 |       "pluginVersion": "7.5.0",
219 |       "pointradius": 2,
220 |       "points": false,
221 |       "renderer": "flot",
222 |       "seriesOverrides": [
223 |         {
224 |           "$$hashKey": "object:97",
225 |           "alias": "velocity_smooth",
226 |           "fill": 0,
227 |           "fillGradient": 0,
228 |           "linewidth": 1,
229 |           "yaxis": 2
230 |         }
231 |       ],
232 |       "spaceLength": 10,
233 |       "stack": false,
234 |       "steppedLine": false,
235 |       "targets": [
236 |         {
237 |           "activityData": "splits",
238 |           "activityGraph": "heartrate",
239 |           "activityId": "$Activity",
240 |           "activityType": "Run",
241 |           "fitToTimeRange": true,
242 |           "queryType": "Activity",
243 |           "refId": "A",
244 |           "selectedActivity": {
245 |             "description": "Variable",
246 |             "label": "$Activity",
247 |             "value": "$Activity"
248 |           },
249 |           "splitStat": "average_heartrate"
250 |         }
251 |       ],
252 |       "thresholds": [],
253 |       "timeFrom": null,
254 |       "timeRegions": [],
255 |       "timeShift": null,
256 |       "title": "Heart Rate Splits",
257 |       "tooltip": {
258 |         "shared": true,
259 |         "sort": 0,
260 |         "value_type": "individual"
261 |       },
262 |       "type": "graph",
263 |       "xaxis": {
264 |         "buckets": null,
265 |         "mode": "time",
266 |         "name": null,
267 |         "show": true,
268 |         "values": []
269 |       },
270 |       "yaxes": [
271 |         {
272 |           "$$hashKey": "object:132",
273 |           "format": "short",
274 |           "label": null,
275 |           "logBase": 1,
276 |           "max": null,
277 |           "min": "0",
278 |           "show": true
279 |         },
280 |         {
281 |           "$$hashKey": "object:133",
282 |           "format": "short",
283 |           "label": null,
284 |           "logBase": 1,
285 |           "max": null,
286 |           "min": null,
287 |           "show": true
288 |         }
289 |       ],
290 |       "yaxis": {
291 |         "align": false,
292 |         "alignLevel": null
293 |       }
294 |     },
295 |     {
296 |       "aliasColors": {
297 |         "heartrate": "red",
298 |         "speed": "blue",
299 |         "velocity_smooth": "blue"
300 |       },
301 |       "bars": false,
302 |       "dashLength": 10,
303 |       "dashes": false,
304 |       "datasource": {
305 |         "type": "grafana-strava-datasource",
306 |         "uid": "${DS_STRAVA}"
307 |       },
308 |       "fieldConfig": {
309 |         "defaults": {
310 |           "unit": "velocityms"
311 |         },
312 |         "overrides": []
313 |       },
314 |       "fill": 1,
315 |       "fillGradient": 7,
316 |       "gridPos": {
317 |         "h": 8,
318 |         "w": 12,
319 |         "x": 0,
320 |         "y": 8
321 |       },
322 |       "hiddenSeries": false,
323 |       "id": 6,
324 |       "legend": {
325 |         "avg": false,
326 |         "current": false,
327 |         "max": false,
328 |         "min": false,
329 |         "show": false,
330 |         "total": false,
331 |         "values": false
332 |       },
333 |       "lines": true,
334 |       "linewidth": 2,
335 |       "nullPointMode": "null",
336 |       "options": {
337 |         "alertThreshold": true
338 |       },
339 |       "percentage": false,
340 |       "pluginVersion": "7.5.0",
341 |       "pointradius": 2,
342 |       "points": false,
343 |       "renderer": "flot",
344 |       "seriesOverrides": [
345 |         {
346 |           "$$hashKey": "object:97",
347 |           "alias": "velocity_smooth",
348 |           "fill": 0,
349 |           "fillGradient": 0,
350 |           "linewidth": 1,
351 |           "yaxis": 1
352 |         }
353 |       ],
354 |       "spaceLength": 10,
355 |       "stack": false,
356 |       "steppedLine": false,
357 |       "targets": [
358 |         {
359 |           "activityData": "graph",
360 |           "activityGraph": "velocity_smooth",
361 |           "activityId": "$Activity",
362 |           "activityType": "Run",
363 |           "fitToTimeRange": true,
364 |           "hide": false,
365 |           "queryType": "Activity",
366 |           "refId": "B",
367 |           "selectedActivity": {
368 |             "description": "Variable",
369 |             "label": "$Activity",
370 |             "value": "$Activity"
371 |           }
372 |         }
373 |       ],
374 |       "thresholds": [],
375 |       "timeFrom": null,
376 |       "timeRegions": [],
377 |       "timeShift": null,
378 |       "title": "Speed",
379 |       "tooltip": {
380 |         "shared": true,
381 |         "sort": 0,
382 |         "value_type": "individual"
383 |       },
384 |       "type": "graph",
385 |       "xaxis": {
386 |         "buckets": null,
387 |         "mode": "time",
388 |         "name": null,
389 |         "show": true,
390 |         "values": []
391 |       },
392 |       "yaxes": [
393 |         {
394 |           "$$hashKey": "object:132",
395 |           "format": "velocityms",
396 |           "label": null,
397 |           "logBase": 1,
398 |           "max": null,
399 |           "min": "0",
400 |           "show": true
401 |         },
402 |         {
403 |           "$$hashKey": "object:133",
404 |           "format": "short",
405 |           "label": null,
406 |           "logBase": 1,
407 |           "max": null,
408 |           "min": null,
409 |           "show": true
410 |         }
411 |       ],
412 |       "yaxis": {
413 |         "align": false,
414 |         "alignLevel": null
415 |       }
416 |     },
417 |     {
418 |       "aliasColors": {
419 |         "Afternoon Run": "red",
420 |         "average_heartrate": "red",
421 |         "average_speed": "blue",
422 |         "heartrate": "red",
423 |         "velocity_smooth": "blue"
424 |       },
425 |       "bars": true,
426 |       "dashLength": 10,
427 |       "dashes": false,
428 |       "datasource": {
429 |         "type": "grafana-strava-datasource",
430 |         "uid": "${DS_STRAVA}"
431 |       },
432 |       "fieldConfig": {
433 |         "defaults": {
434 |           "unit": "short"
435 |         },
436 |         "overrides": []
437 |       },
438 |       "fill": 1,
439 |       "fillGradient": 7,
440 |       "gridPos": {
441 |         "h": 8,
442 |         "w": 12,
443 |         "x": 12,
444 |         "y": 8
445 |       },
446 |       "hiddenSeries": false,
447 |       "id": 8,
448 |       "legend": {
449 |         "avg": false,
450 |         "current": false,
451 |         "max": false,
452 |         "min": false,
453 |         "show": false,
454 |         "total": false,
455 |         "values": false
456 |       },
457 |       "lines": false,
458 |       "linewidth": 2,
459 |       "nullPointMode": "null",
460 |       "options": {
461 |         "alertThreshold": false
462 |       },
463 |       "percentage": false,
464 |       "pluginVersion": "7.5.0",
465 |       "pointradius": 2,
466 |       "points": false,
467 |       "renderer": "flot",
468 |       "seriesOverrides": [
469 |         {
470 |           "$$hashKey": "object:97",
471 |           "alias": "velocity_smooth",
472 |           "fill": 0,
473 |           "fillGradient": 0,
474 |           "linewidth": 1,
475 |           "yaxis": 2
476 |         }
477 |       ],
478 |       "spaceLength": 10,
479 |       "stack": false,
480 |       "steppedLine": false,
481 |       "targets": [
482 |         {
483 |           "activityData": "splits",
484 |           "activityGraph": "heartrate",
485 |           "activityId": "$Activity",
486 |           "activityType": "Run",
487 |           "fitToTimeRange": true,
488 |           "queryType": "Activity",
489 |           "refId": "A",
490 |           "selectedActivity": {
491 |             "description": "Variable",
492 |             "label": "$Activity",
493 |             "value": "$Activity"
494 |           },
495 |           "splitStat": "average_speed"
496 |         }
497 |       ],
498 |       "thresholds": [],
499 |       "timeFrom": null,
500 |       "timeRegions": [],
501 |       "timeShift": null,
502 |       "title": "Speed Splits",
503 |       "tooltip": {
504 |         "shared": true,
505 |         "sort": 0,
506 |         "value_type": "individual"
507 |       },
508 |       "type": "graph",
509 |       "xaxis": {
510 |         "buckets": null,
511 |         "mode": "time",
512 |         "name": null,
513 |         "show": true,
514 |         "values": []
515 |       },
516 |       "yaxes": [
517 |         {
518 |           "$$hashKey": "object:132",
519 |           "format": "short",
520 |           "label": null,
521 |           "logBase": 1,
522 |           "max": null,
523 |           "min": "0",
524 |           "show": true
525 |         },
526 |         {
527 |           "$$hashKey": "object:133",
528 |           "format": "short",
529 |           "label": null,
530 |           "logBase": 1,
531 |           "max": null,
532 |           "min": null,
533 |           "show": true
534 |         }
535 |       ],
536 |       "yaxis": {
537 |         "align": false,
538 |         "alignLevel": null
539 |       }
540 |     },
541 |     {
542 |       "aliasColors": {
543 |         "heartrate": "red",
544 |         "velocity_smooth": "blue"
545 |       },
546 |       "bars": false,
547 |       "dashLength": 10,
548 |       "dashes": false,
549 |       "datasource": {
550 |         "type": "grafana-strava-datasource",
551 |         "uid": "${DS_STRAVA}"
552 |       },
553 |       "fieldConfig": {
554 |         "defaults": {
555 |           "unit": "none"
556 |         },
557 |         "overrides": []
558 |       },
559 |       "fill": 0,
560 |       "fillGradient": 7,
561 |       "gridPos": {
562 |         "h": 7,
563 |         "w": 12,
564 |         "x": 0,
565 |         "y": 16
566 |       },
567 |       "hiddenSeries": false,
568 |       "id": 9,
569 |       "legend": {
570 |         "avg": false,
571 |         "current": false,
572 |         "max": false,
573 |         "min": false,
574 |         "show": false,
575 |         "total": false,
576 |         "values": false
577 |       },
578 |       "lines": true,
579 |       "linewidth": 2,
580 |       "nullPointMode": "null",
581 |       "options": {
582 |         "alertThreshold": false
583 |       },
584 |       "percentage": false,
585 |       "pluginVersion": "7.5.0",
586 |       "pointradius": 2,
587 |       "points": false,
588 |       "renderer": "flot",
589 |       "seriesOverrides": [
590 |         {
591 |           "$$hashKey": "object:97",
592 |           "alias": "velocity_smooth",
593 |           "fill": 0,
594 |           "fillGradient": 0,
595 |           "linewidth": 1,
596 |           "yaxis": 1
597 |         }
598 |       ],
599 |       "spaceLength": 10,
600 |       "stack": false,
601 |       "steppedLine": false,
602 |       "targets": [
603 |         {
604 |           "activityData": "graph",
605 |           "activityGraph": "altitude",
606 |           "activityId": "$Activity",
607 |           "activityType": "Run",
608 |           "fitToTimeRange": true,
609 |           "hide": false,
610 |           "queryType": "Activity",
611 |           "refId": "B",
612 |           "selectedActivity": {
613 |             "description": "Variable",
614 |             "label": "$Activity",
615 |             "value": "$Activity"
616 |           }
617 |         }
618 |       ],
619 |       "thresholds": [],
620 |       "timeFrom": null,
621 |       "timeRegions": [],
622 |       "timeShift": null,
623 |       "title": "Altitude",
624 |       "tooltip": {
625 |         "shared": true,
626 |         "sort": 0,
627 |         "value_type": "individual"
628 |       },
629 |       "type": "graph",
630 |       "xaxis": {
631 |         "buckets": null,
632 |         "mode": "time",
633 |         "name": null,
634 |         "show": true,
635 |         "values": []
636 |       },
637 |       "yaxes": [
638 |         {
639 |           "$$hashKey": "object:132",
640 |           "format": "none",
641 |           "label": null,
642 |           "logBase": 1,
643 |           "max": null,
644 |           "min": null,
645 |           "show": true
646 |         },
647 |         {
648 |           "$$hashKey": "object:133",
649 |           "format": "short",
650 |           "label": null,
651 |           "logBase": 1,
652 |           "max": null,
653 |           "min": null,
654 |           "show": true
655 |         }
656 |       ],
657 |       "yaxis": {
658 |         "align": false,
659 |         "alignLevel": null
660 |       }
661 |     },
662 |     {
663 |       "aliasColors": {
664 |         "heartrate": "red",
665 |         "velocity_smooth": "blue",
666 |         "watts_calc": "orange"
667 |       },
668 |       "bars": false,
669 |       "dashLength": 10,
670 |       "dashes": false,
671 |       "datasource": {
672 |         "type": "grafana-strava-datasource",
673 |         "uid": "${DS_STRAVA}"
674 |       },
675 |       "fieldConfig": {
676 |         "defaults": {
677 |           "unit": "watt"
678 |         },
679 |         "overrides": []
680 |       },
681 |       "fill": 0,
682 |       "fillGradient": 0,
683 |       "gridPos": {
684 |         "h": 7,
685 |         "w": 12,
686 |         "x": 12,
687 |         "y": 16
688 |       },
689 |       "hiddenSeries": false,
690 |       "id": 10,
691 |       "legend": {
692 |         "avg": false,
693 |         "current": false,
694 |         "max": false,
695 |         "min": false,
696 |         "show": false,
697 |         "total": false,
698 |         "values": false
699 |       },
700 |       "lines": true,
701 |       "linewidth": 1,
702 |       "nullPointMode": "null",
703 |       "options": {
704 |         "alertThreshold": false
705 |       },
706 |       "percentage": false,
707 |       "pluginVersion": "7.5.0",
708 |       "pointradius": 2,
709 |       "points": false,
710 |       "renderer": "flot",
711 |       "seriesOverrides": [
712 |         {
713 |           "$$hashKey": "object:97",
714 |           "alias": "velocity_smooth",
715 |           "fill": 0,
716 |           "fillGradient": 0,
717 |           "linewidth": 1,
718 |           "yaxis": 1
719 |         }
720 |       ],
721 |       "spaceLength": 10,
722 |       "stack": false,
723 |       "steppedLine": false,
724 |       "targets": [
725 |         {
726 |           "activityData": "graph",
727 |           "activityGraph": "watts_calc",
728 |           "activityId": "$Activity",
729 |           "activityType": "Run",
730 |           "fitToTimeRange": true,
731 |           "hide": false,
732 |           "queryType": "Activity",
733 |           "refId": "B",
734 |           "selectedActivity": {
735 |             "description": "Variable",
736 |             "label": "$Activity",
737 |             "value": "$Activity"
738 |           },
739 |           "splitStat": "moving_time"
740 |         }
741 |       ],
742 |       "thresholds": [],
743 |       "timeFrom": null,
744 |       "timeRegions": [],
745 |       "timeShift": null,
746 |       "title": "Est. Power (Cycling)",
747 |       "tooltip": {
748 |         "shared": true,
749 |         "sort": 0,
750 |         "value_type": "individual"
751 |       },
752 |       "type": "graph",
753 |       "xaxis": {
754 |         "buckets": null,
755 |         "mode": "time",
756 |         "name": null,
757 |         "show": true,
758 |         "values": []
759 |       },
760 |       "yaxes": [
761 |         {
762 |           "$$hashKey": "object:132",
763 |           "format": "watt",
764 |           "label": null,
765 |           "logBase": 1,
766 |           "max": null,
767 |           "min": null,
768 |           "show": true
769 |         },
770 |         {
771 |           "$$hashKey": "object:133",
772 |           "format": "short",
773 |           "label": null,
774 |           "logBase": 1,
775 |           "max": null,
776 |           "min": null,
777 |           "show": true
778 |         }
779 |       ],
780 |       "yaxis": {
781 |         "align": false,
782 |         "alignLevel": null
783 |       }
784 |     }
785 |   ],
786 |   "refresh": false,
787 |   "schemaVersion": 27,
788 |   "style": "dark",
789 |   "tags": [],
790 |   "templating": {
791 |     "list": [
792 |       {
793 |         "allValue": null,
794 |         "current": {},
795 |         "datasource": {
796 |         "type": "grafana-strava-datasource",
797 |         "uid": "${DS_STRAVA}"
798 |       },
799 |         "definition": "Strava - activity",
800 |         "description": null,
801 |         "error": null,
802 |         "hide": 0,
803 |         "includeAll": false,
804 |         "label": null,
805 |         "multi": false,
806 |         "name": "Activity",
807 |         "options": [],
808 |         "query": {
809 |           "activityType": "",
810 |           "queryType": "activity"
811 |         },
812 |         "refresh": 1,
813 |         "regex": "",
814 |         "skipUrlSync": false,
815 |         "sort": 0,
816 |         "tagValuesQuery": "",
817 |         "tags": [],
818 |         "tagsQuery": "",
819 |         "type": "query",
820 |         "useTags": false
821 |       }
822 |     ]
823 |   },
824 |   "time": {
825 |     "from": "now-3h",
826 |     "to": "now"
827 |   },
828 |   "timepicker": {},
829 |   "timezone": "",
830 |   "title": "Strava Activity Analysis",
831 |   "uid": "StravaActivityAnalysis-v1",
832 |   "version": 2
833 | }
834 | 


--------------------------------------------------------------------------------
/src/dashboards/strava_segment_overview.json:
--------------------------------------------------------------------------------
  1 | {
  2 |   "__inputs": [
  3 |     {
  4 |       "name": "DS_STRAVA",
  5 |       "label": "Strava",
  6 |       "description": "",
  7 |       "type": "datasource",
  8 |       "pluginId": "grafana-strava-datasource",
  9 |       "pluginName": "Strava"
 10 |     }
 11 |   ],
 12 |   "__elements": {},
 13 |   "__requires": [
 14 |     {
 15 |       "type": "panel",
 16 |       "id": "geomap",
 17 |       "name": "Geomap",
 18 |       "version": ""
 19 |     },
 20 |     {
 21 |       "type": "grafana",
 22 |       "id": "grafana",
 23 |       "name": "Grafana",
 24 |       "version": "9.1.1"
 25 |     },
 26 |     {
 27 |       "type": "datasource",
 28 |       "id": "grafana-strava-datasource",
 29 |       "name": "Strava",
 30 |       "version": "1.4.1"
 31 |     },
 32 |     {
 33 |       "type": "panel",
 34 |       "id": "timeseries",
 35 |       "name": "Time series",
 36 |       "version": ""
 37 |     }
 38 |   ],
 39 |   "annotations": {
 40 |     "list": [
 41 |       {
 42 |         "builtIn": 1,
 43 |         "datasource": {
 44 |           "type": "grafana",
 45 |           "uid": "-- Grafana --"
 46 |         },
 47 |         "enable": true,
 48 |         "hide": true,
 49 |         "iconColor": "rgba(0, 211, 255, 1)",
 50 |         "name": "Annotations & Alerts",
 51 |         "target": {
 52 |           "limit": 100,
 53 |           "matchAny": false,
 54 |           "tags": [],
 55 |           "type": "dashboard"
 56 |         },
 57 |         "type": "dashboard"
 58 |       }
 59 |     ]
 60 |   },
 61 |   "editable": true,
 62 |   "fiscalYearStartMonth": 0,
 63 |   "graphTooltip": 1,
 64 |   "id": null,
 65 |   "links": [],
 66 |   "liveNow": false,
 67 |   "panels": [
 68 |     {
 69 |       "datasource": {
 70 |         "type": "grafana-strava-datasource",
 71 |         "uid": "${DS_STRAVA}"
 72 |       },
 73 |       "fieldConfig": {
 74 |         "defaults": {
 75 |           "color": {
 76 |             "mode": "thresholds"
 77 |           },
 78 |           "custom": {
 79 |             "hideFrom": {
 80 |               "legend": false,
 81 |               "tooltip": false,
 82 |               "viz": false
 83 |             }
 84 |           },
 85 |           "mappings": [],
 86 |           "thresholds": {
 87 |             "mode": "absolute",
 88 |             "steps": [
 89 |               {
 90 |                 "color": "green",
 91 |                 "value": null
 92 |               },
 93 |               {
 94 |                 "color": "red",
 95 |                 "value": 80
 96 |               }
 97 |             ]
 98 |           }
 99 |         },
100 |         "overrides": []
101 |       },
102 |       "gridPos": {
103 |         "h": 9,
104 |         "w": 12,
105 |         "x": 0,
106 |         "y": 0
107 |       },
108 |       "id": 2,
109 |       "options": {
110 |         "basemap": {
111 |           "config": {},
112 |           "name": "Layer 0",
113 |           "type": "default"
114 |         },
115 |         "controls": {
116 |           "mouseWheelZoom": false,
117 |           "showAttribution": true,
118 |           "showDebug": false,
119 |           "showScale": false,
120 |           "showZoom": true
121 |         },
122 |         "layers": [
123 |           {
124 |             "config": {
125 |               "style": {
126 |                 "color": {
127 |                   "fixed": "#FF780A"
128 |                 },
129 |                 "lineWidth": 2,
130 |                 "opacity": 1,
131 |                 "rotation": {
132 |                   "fixed": 0,
133 |                   "max": 360,
134 |                   "min": -360,
135 |                   "mode": "mod"
136 |                 },
137 |                 "size": {
138 |                   "fixed": 5,
139 |                   "max": 15,
140 |                   "min": 2
141 |                 },
142 |                 "symbol": {
143 |                   "fixed": "img/icons/marker/circle.svg",
144 |                   "mode": "fixed"
145 |                 },
146 |                 "textConfig": {
147 |                   "fontSize": 12,
148 |                   "offsetX": 0,
149 |                   "offsetY": 0,
150 |                   "textAlign": "center",
151 |                   "textBaseline": "middle"
152 |                 }
153 |               }
154 |             },
155 |             "filterData": {
156 |               "id": "byRefId",
157 |               "options": "A"
158 |             },
159 |             "name": "Activity",
160 |             "tooltip": true,
161 |             "type": "route"
162 |           },
163 |           {
164 |             "config": {
165 |               "style": {
166 |                 "color": {
167 |                   "fixed": "#1250B0"
168 |                 },
169 |                 "lineWidth": 2,
170 |                 "opacity": 1,
171 |                 "rotation": {
172 |                   "fixed": 0,
173 |                   "max": 360,
174 |                   "min": -360,
175 |                   "mode": "mod"
176 |                 },
177 |                 "size": {
178 |                   "fixed": 5,
179 |                   "max": 15,
180 |                   "min": 2
181 |                 },
182 |                 "symbol": {
183 |                   "fixed": "img/icons/marker/circle.svg",
184 |                   "mode": "fixed"
185 |                 },
186 |                 "textConfig": {
187 |                   "fontSize": 12,
188 |                   "offsetX": 0,
189 |                   "offsetY": 0,
190 |                   "textAlign": "center",
191 |                   "textBaseline": "middle"
192 |                 }
193 |               }
194 |             },
195 |             "filterData": {
196 |               "id": "byRefId",
197 |               "options": "B"
198 |             },
199 |             "location": {
200 |               "mode": "auto"
201 |             },
202 |             "name": "Segment",
203 |             "tooltip": true,
204 |             "type": "route"
205 |           }
206 |         ],
207 |         "tooltip": {
208 |           "mode": "details"
209 |         },
210 |         "view": {
211 |           "id": "fit",
212 |           "lat": 0,
213 |           "lon": 0,
214 |           "zoom": 15
215 |         }
216 |       },
217 |       "pluginVersion": "9.1.1",
218 |       "targets": [
219 |         {
220 |           "activityData": "geomap",
221 |           "activityGraph": "velocity_smooth",
222 |           "activityId": "$activity",
223 |           "activityStat": "distance",
224 |           "datasource": {
225 |             "type": "grafana-strava-datasource",
226 |             "uid": "${DS_STRAVA}"
227 |           },
228 |           "extendedStats": [],
229 |           "fitToTimeRange": false,
230 |           "format": "time_series",
231 |           "interval": "auto",
232 |           "queryType": "Activity",
233 |           "refId": "A",
234 |           "selectedActivity": {
235 |             "description": "Variable",
236 |             "label": "$activity",
237 |             "value": "$activity"
238 |           },
239 |           "singleActivityStat": "name",
240 |           "splitStat": "average_speed"
241 |         },
242 |         {
243 |           "activityData": "geomap",
244 |           "activityGraph": "velocity_smooth",
245 |           "activityId": "$activity",
246 |           "activityStat": "distance",
247 |           "datasource": {
248 |             "type": "grafana-strava-datasource",
249 |             "uid": "${DS_STRAVA}"
250 |           },
251 |           "extendedStats": [],
252 |           "fitToTimeRange": false,
253 |           "format": "time_series",
254 |           "hide": false,
255 |           "interval": "auto",
256 |           "queryType": "SegmentEffort",
257 |           "refId": "B",
258 |           "segmentData": "geomap",
259 |           "segmentEffortId": "$segment",
260 |           "segmentGraph": "pace",
261 |           "selectedActivity": {
262 |             "description": "Variable",
263 |             "label": "$activity",
264 |             "value": "$activity"
265 |           },
266 |           "selectedSegmentEffort": {
267 |             "description": "Variable",
268 |             "label": "$segment",
269 |             "value": "$segment"
270 |           },
271 |           "singleActivityStat": "name",
272 |           "splitStat": "average_speed"
273 |         }
274 |       ],
275 |       "title": "Activity map",
276 |       "type": "geomap"
277 |     },
278 |     {
279 |       "datasource": {
280 |         "type": "grafana-strava-datasource",
281 |         "uid": "${DS_STRAVA}"
282 |       },
283 |       "fieldConfig": {
284 |         "defaults": {
285 |           "color": {
286 |             "mode": "thresholds"
287 |           },
288 |           "custom": {
289 |             "hideFrom": {
290 |               "legend": false,
291 |               "tooltip": false,
292 |               "viz": false
293 |             }
294 |           },
295 |           "mappings": [],
296 |           "thresholds": {
297 |             "mode": "absolute",
298 |             "steps": [
299 |               {
300 |                 "color": "green",
301 |                 "value": null
302 |               },
303 |               {
304 |                 "color": "red",
305 |                 "value": 80
306 |               }
307 |             ]
308 |           }
309 |         },
310 |         "overrides": []
311 |       },
312 |       "gridPos": {
313 |         "h": 9,
314 |         "w": 12,
315 |         "x": 12,
316 |         "y": 0
317 |       },
318 |       "id": 5,
319 |       "options": {
320 |         "basemap": {
321 |           "config": {},
322 |           "name": "Layer 0",
323 |           "type": "default"
324 |         },
325 |         "controls": {
326 |           "mouseWheelZoom": false,
327 |           "showAttribution": true,
328 |           "showDebug": false,
329 |           "showScale": false,
330 |           "showZoom": true
331 |         },
332 |         "layers": [
333 |           {
334 |             "config": {
335 |               "style": {
336 |                 "color": {
337 |                   "fixed": "#1250B0"
338 |                 },
339 |                 "lineWidth": 2,
340 |                 "opacity": 1,
341 |                 "rotation": {
342 |                   "fixed": 0,
343 |                   "max": 360,
344 |                   "min": -360,
345 |                   "mode": "mod"
346 |                 },
347 |                 "size": {
348 |                   "fixed": 5,
349 |                   "max": 15,
350 |                   "min": 2
351 |                 },
352 |                 "symbol": {
353 |                   "fixed": "img/icons/marker/circle.svg",
354 |                   "mode": "fixed"
355 |                 },
356 |                 "textConfig": {
357 |                   "fontSize": 12,
358 |                   "offsetX": 0,
359 |                   "offsetY": 0,
360 |                   "textAlign": "center",
361 |                   "textBaseline": "middle"
362 |                 }
363 |               }
364 |             },
365 |             "name": "Layer 1",
366 |             "tooltip": true,
367 |             "type": "route"
368 |           }
369 |         ],
370 |         "tooltip": {
371 |           "mode": "details"
372 |         },
373 |         "view": {
374 |           "id": "fit",
375 |           "lat": 0,
376 |           "lon": 0,
377 |           "zoom": 15
378 |         }
379 |       },
380 |       "pluginVersion": "9.1.1",
381 |       "targets": [
382 |         {
383 |           "activityData": "geomap",
384 |           "activityGraph": "velocity_smooth",
385 |           "activityId": "$activity",
386 |           "activityStat": "distance",
387 |           "datasource": {
388 |             "type": "grafana-strava-datasource",
389 |             "uid": "${DS_STRAVA}"
390 |           },
391 |           "extendedStats": [],
392 |           "fitToTimeRange": false,
393 |           "format": "time_series",
394 |           "interval": "auto",
395 |           "queryType": "SegmentEffort",
396 |           "refId": "A",
397 |           "segmentData": "geomap",
398 |           "segmentEffortId": "$segment",
399 |           "segmentGraph": "pace",
400 |           "selectedActivity": {
401 |             "description": "Variable",
402 |             "label": "$activity",
403 |             "value": "$activity"
404 |           },
405 |           "selectedSegmentEffort": {
406 |             "description": "Variable",
407 |             "label": "$segment",
408 |             "value": "$segment"
409 |           },
410 |           "singleActivityStat": "name",
411 |           "splitStat": "average_speed"
412 |         }
413 |       ],
414 |       "title": "Segment map",
415 |       "type": "geomap"
416 |     },
417 |     {
418 |       "datasource": {
419 |         "type": "grafana-strava-datasource",
420 |         "uid": "${DS_STRAVA}"
421 |       },
422 |       "fieldConfig": {
423 |         "defaults": {
424 |           "color": {
425 |             "mode": "palette-classic"
426 |           },
427 |           "custom": {
428 |             "axisCenteredZero": false,
429 |             "axisColorMode": "text",
430 |             "axisLabel": "",
431 |             "axisPlacement": "auto",
432 |             "barAlignment": 0,
433 |             "drawStyle": "line",
434 |             "fillOpacity": 70,
435 |             "gradientMode": "opacity",
436 |             "hideFrom": {
437 |               "legend": false,
438 |               "tooltip": false,
439 |               "viz": false
440 |             },
441 |             "lineInterpolation": "smooth",
442 |             "lineWidth": 0,
443 |             "pointSize": 5,
444 |             "scaleDistribution": {
445 |               "type": "linear"
446 |             },
447 |             "showPoints": "never",
448 |             "spanNulls": false,
449 |             "stacking": {
450 |               "group": "A",
451 |               "mode": "none"
452 |             },
453 |             "thresholdsStyle": {
454 |               "mode": "off"
455 |             }
456 |           },
457 |           "mappings": [],
458 |           "min": 0,
459 |           "thresholds": {
460 |             "mode": "absolute",
461 |             "steps": [
462 |               {
463 |                 "color": "green",
464 |                 "value": null
465 |               },
466 |               {
467 |                 "color": "red",
468 |                 "value": 80
469 |               }
470 |             ]
471 |           },
472 |           "unit": "short"
473 |         },
474 |         "overrides": [
475 |           {
476 |             "matcher": {
477 |               "id": "byName",
478 |               "options": "heartrate"
479 |             },
480 |             "properties": [
481 |               {
482 |                 "id": "color",
483 |                 "value": {
484 |                   "fixedColor": "semi-dark-red",
485 |                   "mode": "fixed"
486 |                 }
487 |               }
488 |             ]
489 |           },
490 |           {
491 |             "matcher": {
492 |               "id": "byFrameRefID",
493 |               "options": "B"
494 |             },
495 |             "properties": [
496 |               {
497 |                 "id": "color",
498 |                 "value": {
499 |                   "fixedColor": "semi-dark-blue",
500 |                   "mode": "fixed"
501 |                 }
502 |               },
503 |               {
504 |                 "id": "custom.lineWidth",
505 |                 "value": 2
506 |               },
507 |               {
508 |                 "id": "custom.fillOpacity",
509 |                 "value": 0
510 |               }
511 |             ]
512 |           }
513 |         ]
514 |       },
515 |       "gridPos": {
516 |         "h": 7,
517 |         "w": 24,
518 |         "x": 0,
519 |         "y": 9
520 |       },
521 |       "id": 9,
522 |       "options": {
523 |         "legend": {
524 |           "calcs": [],
525 |           "displayMode": "list",
526 |           "placement": "bottom",
527 |           "showLegend": true
528 |         },
529 |         "tooltip": {
530 |           "mode": "multi",
531 |           "sort": "none"
532 |         }
533 |       },
534 |       "pluginVersion": "8.1.0",
535 |       "targets": [
536 |         {
537 |           "activityData": "graph",
538 |           "activityGraph": "heartrate",
539 |           "activityId": "$activity",
540 |           "activityStat": "distance",
541 |           "activityType": "Run",
542 |           "datasource": {
543 |             "type": "grafana-strava-datasource",
544 |             "uid": "${DS_STRAVA}"
545 |           },
546 |           "extendedStats": [],
547 |           "fitToTimeRange": false,
548 |           "format": "time_series",
549 |           "interval": "auto",
550 |           "queryType": "SegmentEffort",
551 |           "refId": "A",
552 |           "segmentData": "graph",
553 |           "segmentEffortId": "$segment",
554 |           "segmentGraph": "heartrate",
555 |           "selectedActivity": {
556 |             "description": "Variable",
557 |             "label": "$activity",
558 |             "value": "$activity"
559 |           },
560 |           "selectedSegmentEffort": {
561 |             "description": "Variable",
562 |             "label": "$segment",
563 |             "value": "$segment"
564 |           },
565 |           "singleActivityStat": "name",
566 |           "splitStat": "average_speed"
567 |         },
568 |         {
569 |           "activityData": "graph",
570 |           "activityGraph": "pace",
571 |           "activityId": "$activity",
572 |           "activityStat": "distance",
573 |           "activityType": "Run",
574 |           "datasource": {
575 |             "type": "grafana-strava-datasource",
576 |             "uid": "${DS_STRAVA}"
577 |           },
578 |           "extendedStats": [],
579 |           "fitToTimeRange": false,
580 |           "format": "time_series",
581 |           "hide": false,
582 |           "interval": "auto",
583 |           "queryType": "SegmentEffort",
584 |           "refId": "B",
585 |           "segmentData": "graph",
586 |           "segmentEffortId": "$segment",
587 |           "segmentGraph": "pace",
588 |           "selectedActivity": {
589 |             "description": "Variable",
590 |             "label": "$activity",
591 |             "value": "$activity"
592 |           },
593 |           "selectedSegmentEffort": {
594 |             "description": "Variable",
595 |             "label": "$segment",
596 |             "value": "$segment"
597 |           },
598 |           "singleActivityStat": "name",
599 |           "splitStat": "average_speed"
600 |         }
601 |       ],
602 |       "title": "Heart rate / Speed",
603 |       "type": "timeseries"
604 |     },
605 |     {
606 |       "datasource": {
607 |         "type": "grafana-strava-datasource",
608 |         "uid": "${DS_STRAVA}"
609 |       },
610 |       "fieldConfig": {
611 |         "defaults": {
612 |           "color": {
613 |             "mode": "fixed"
614 |           },
615 |           "custom": {
616 |             "axisCenteredZero": false,
617 |             "axisColorMode": "text",
618 |             "axisLabel": "",
619 |             "axisPlacement": "auto",
620 |             "barAlignment": 0,
621 |             "drawStyle": "line",
622 |             "fillOpacity": 50,
623 |             "gradientMode": "opacity",
624 |             "hideFrom": {
625 |               "legend": false,
626 |               "tooltip": false,
627 |               "viz": false
628 |             },
629 |             "lineInterpolation": "linear",
630 |             "lineWidth": 2,
631 |             "pointSize": 5,
632 |             "scaleDistribution": {
633 |               "type": "linear"
634 |             },
635 |             "showPoints": "never",
636 |             "spanNulls": false,
637 |             "stacking": {
638 |               "group": "A",
639 |               "mode": "none"
640 |             },
641 |             "thresholdsStyle": {
642 |               "mode": "off"
643 |             }
644 |           },
645 |           "mappings": [],
646 |           "thresholds": {
647 |             "mode": "absolute",
648 |             "steps": [
649 |               {
650 |                 "color": "green",
651 |                 "value": null
652 |               },
653 |               {
654 |                 "color": "red",
655 |                 "value": 80
656 |               }
657 |             ]
658 |           },
659 |           "unit": "lengthm"
660 |         },
661 |         "overrides": []
662 |       },
663 |       "gridPos": {
664 |         "h": 4,
665 |         "w": 24,
666 |         "x": 0,
667 |         "y": 16
668 |       },
669 |       "id": 7,
670 |       "options": {
671 |         "legend": {
672 |           "calcs": [],
673 |           "displayMode": "list",
674 |           "placement": "bottom",
675 |           "showLegend": false
676 |         },
677 |         "tooltip": {
678 |           "mode": "single",
679 |           "sort": "none"
680 |         }
681 |       },
682 |       "pluginVersion": "9.1.0-pre",
683 |       "targets": [
684 |         {
685 |           "activityData": "graph",
686 |           "activityGraph": "altitude",
687 |           "activityId": "$activity",
688 |           "activityStat": "distance",
689 |           "activityType": "Run",
690 |           "datasource": {
691 |             "type": "grafana-strava-datasource",
692 |             "uid": "${DS_STRAVA}"
693 |           },
694 |           "extendedStats": [],
695 |           "fitToTimeRange": false,
696 |           "format": "time_series",
697 |           "interval": "auto",
698 |           "queryType": "SegmentEffort",
699 |           "refId": "A",
700 |           "segmentData": "graph",
701 |           "segmentEffortId": "$segment",
702 |           "segmentGraph": "altitude",
703 |           "selectedActivity": {
704 |             "description": "Variable",
705 |             "label": "$activity",
706 |             "value": "$activity"
707 |           },
708 |           "selectedSegmentEffort": {
709 |             "description": "Variable",
710 |             "label": "$segment",
711 |             "value": "$segment"
712 |           },
713 |           "singleActivityStat": "name",
714 |           "splitStat": "average_speed"
715 |         }
716 |       ],
717 |       "title": "Altitude",
718 |       "type": "timeseries"
719 |     }
720 |   ],
721 |   "refresh": false,
722 |   "schemaVersion": 37,
723 |   "style": "dark",
724 |   "tags": [],
725 |   "templating": {
726 |     "list": [
727 |       {
728 |         "current": {},
729 |         "datasource": {
730 |           "type": "grafana-strava-datasource",
731 |           "uid": "${DS_STRAVA}"
732 |         },
733 |         "definition": "Strava - activity",
734 |         "hide": 0,
735 |         "includeAll": false,
736 |         "label": "Activity",
737 |         "multi": false,
738 |         "name": "activity",
739 |         "options": [],
740 |         "query": {
741 |           "activityType": "",
742 |           "limit": 10,
743 |           "queryType": "activity"
744 |         },
745 |         "refresh": 1,
746 |         "regex": "",
747 |         "skipUrlSync": false,
748 |         "sort": 0,
749 |         "type": "query"
750 |       },
751 |       {
752 |         "current": {},
753 |         "datasource": {
754 |           "type": "grafana-strava-datasource",
755 |           "uid": "${DS_STRAVA}"
756 |         },
757 |         "definition": "Strava - segment_effort",
758 |         "hide": 0,
759 |         "includeAll": false,
760 |         "label": "Segment",
761 |         "multi": false,
762 |         "name": "segment",
763 |         "options": [],
764 |         "query": {
765 |           "activityId": "$activity",
766 |           "queryType": "segment_effort"
767 |         },
768 |         "refresh": 1,
769 |         "regex": "",
770 |         "skipUrlSync": false,
771 |         "sort": 0,
772 |         "type": "query"
773 |       }
774 |     ]
775 |   },
776 |   "time": {
777 |     "from": "2022-08-23T15:52:21.000Z",
778 |     "to": "2022-08-23T15:56:58.000Z"
779 |   },
780 |   "timepicker": {},
781 |   "timezone": "",
782 |   "title": "Strava Segment Overview",
783 |   "uid": "StravaSegmentOverview",
784 |   "version": 1,
785 |   "weekStart": ""
786 | }
787 | 


--------------------------------------------------------------------------------
/src/datasource.test.ts:
--------------------------------------------------------------------------------
 1 | import { dateMath } from '@grafana/data';
 2 | import StravaDatasource from './datasource';
 3 | import { StravaQueryType } from './types';
 4 | 
 5 | jest.mock(
 6 |   '@grafana/runtime',
 7 |   () => ({
 8 |     getBackendSrv: () => ({
 9 |       datasourceRequest: jest.fn().mockResolvedValue({ data: { result: '' } }),
10 |       fetch: () => ({
11 |         toPromise: () => jest.fn().mockResolvedValue({ data: { result: '' } }),
12 |       }),
13 |     }),
14 |     getTemplateSrv: () => ({
15 |       replace: jest.fn().mockImplementation((query) => query),
16 |     }),
17 |   }),
18 |   { virtual: true }
19 | );
20 | 
21 | describe('StravaDatasource', () => {
22 |   const ctx: any = {
23 |     backendSrv: {},
24 |     templateSrv: {},
25 |     ds: undefined,
26 |     options: undefined,
27 |     instanceSettings: {} as any,
28 |     timeSrv: {
29 |       timeRange: () => {
30 |         return {
31 |           to: { diff: () => 3600 },
32 |           from: {},
33 |         };
34 |       },
35 |     },
36 |   };
37 | 
38 |   beforeEach(() => {
39 |     ctx.backendSrv = {
40 |       datasourceRequest: () => {
41 |         return Promise.resolve({
42 |           status: 200,
43 |           data: {},
44 |         });
45 |       },
46 |     };
47 |     ctx.templateSrv = {
48 |       replace: (str: string, scopedVars: any) => {
49 |         for (const key in scopedVars) {
50 |           str = str.replace(`$${key}`, scopedVars[key].value);
51 |         }
52 |         return str;
53 |       },
54 |     };
55 | 
56 |     ctx.instanceSettings = {
57 |       id: 123,
58 |       url: '',
59 |       jsonData: {
60 |         oauthPassThru: false,
61 |       },
62 |     };
63 |     ctx.ds = new StravaDatasource(ctx.instanceSettings);
64 |   });
65 | 
66 |   describe('When query activities', () => {
67 |     beforeEach(() => {
68 |       const targets = [
69 |         {
70 |           queryType: StravaQueryType.Activities,
71 |         },
72 |       ];
73 | 
74 |       ctx.options = {
75 |         range: {
76 |           from: dateMath.parse('2023-01-01T00:00:01.000+00:00'),
77 |           to: dateMath.parse('2023-06-01T00:00:00.000+00:00'),
78 |         },
79 |         targets,
80 |       };
81 |     });
82 | 
83 |     it('should round time range to hit the cache', async () => {
84 |       const spy = jest.spyOn(ctx.ds.stravaApi, 'getActivities');
85 |       await ctx.ds.query(ctx.options);
86 |       expect(spy).toHaveBeenLastCalledWith({
87 |         after: 1672531200,
88 |         before: 1685577600,
89 |       });
90 |     });
91 |   });
92 | });
93 | 


--------------------------------------------------------------------------------
/src/img/btn_strava_connectwith_orange.svg:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8" standalone="no"?>
 2 | <svg width="193px" height="48px" viewBox="0 0 193 48" version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink">
 3 |     <!-- Generator: Sketch 39.1 (31720) - http://www.bohemiancoding.com/sketch -->
 4 |     <title>btn_strava_connectwith_orange</title>
 5 |     <desc>Created with Sketch.</desc>
 6 |     <defs></defs>
 7 |     <g id="Strava-Button_outlined" stroke="none" stroke-width="1" fill="none" fill-rule="evenodd">
 8 |         <g id="btn_strava_connectwith_orange">
 9 |             <rect id="button-bg" fill="#FC4C02" x="4" y="4" width="185" height="40" rx="2"></rect>
10 |             <path d="M27,25.164 L28.736,25.514 C28.6239994,26.6153388 28.2226701,27.5066633 27.532,28.188 C26.8413299,28.8693367 25.9500055,29.21 24.858,29.21 C23.6166605,29.21 22.6016706,28.7760043 21.813,27.908 C21.0243294,27.0399957 20.63,25.7426753 20.63,24.016 C20.63,22.4106586 21.0429959,21.171671 21.869,20.299 C22.6950041,19.426329 23.6866609,18.99 24.844,18.99 C25.8613384,18.99 26.7199965,19.3096635 27.42,19.949 C28.1200035,20.5883365 28.5306661,21.4306614 28.652,22.476 L26.944,22.742 C26.7013321,21.2579926 26.0060057,20.516 24.858,20.516 C24.1393297,20.516 23.5396691,20.8053304 23.059,21.384 C22.5783309,21.9626696 22.338,22.8493274 22.338,24.044 C22.338,25.2666728 22.5736643,26.178997 23.045,26.781 C23.5163357,27.383003 24.120663,27.684 24.858,27.684 C26.0806728,27.684 26.7946656,26.8440084 27,25.164 L27,25.164 Z M33.51875,27.768 C34.0694194,27.768 34.5150816,27.5510022 34.85575,27.117 C35.1964184,26.6829978 35.36675,26.0740039 35.36675,25.29 C35.36675,24.5059961 35.1964184,23.8970022 34.85575,23.463 C34.5150816,23.0289978 34.0694194,22.812 33.51875,22.812 C32.9587472,22.812 32.5084184,23.0266645 32.16775,23.456 C31.8270816,23.8853355 31.65675,24.4966627 31.65675,25.29 C31.65675,26.0926707 31.8270816,26.7063312 32.16775,27.131 C32.5084184,27.5556688 32.9587472,27.768 33.51875,27.768 L33.51875,27.768 Z M33.51875,29.21 C32.5200783,29.21 31.6964199,28.8646701 31.04775,28.174 C30.3990801,27.4833299 30.07475,26.5220062 30.07475,25.29 C30.07475,24.0766606 30.4084133,23.1200035 31.07575,22.42 C31.7430867,21.7199965 32.5574119,21.37 33.51875,21.37 C34.4800881,21.37 35.2897467,21.7199965 35.94775,22.42 C36.6057533,23.1200035 36.93475,24.0766606 36.93475,25.29 C36.93475,26.5220062 36.6150865,27.4833299 35.97575,28.174 C35.3364135,28.8646701 34.5174217,29.21 33.51875,29.21 L33.51875,29.21 Z M38.7635,29 L38.7635,21.58 L40.3035,21.58 L40.3035,22.294 L40.3315,22.294 C40.5368344,22.0326654 40.8214982,21.8133342 41.1855,21.636 C41.5495018,21.4586658 41.9321647,21.37 42.3335,21.37 C43.1548374,21.37 43.8011643,21.6149976 44.2725,22.105 C44.7438357,22.5950024 44.9795,23.2739957 44.9795,24.142 L44.9795,29 L43.3975,29 L43.3975,24.562 C43.3975,23.4139943 42.9168381,22.84 41.9555,22.84 C41.4701642,22.84 41.0828348,22.9799986 40.7935,23.26 C40.5041652,23.5400014 40.3595,23.9179976 40.3595,24.394 L40.3595,29 L38.7635,29 Z M47.22825,29 L47.22825,21.58 L48.76825,21.58 L48.76825,22.294 L48.79625,22.294 C49.0015844,22.0326654 49.2862482,21.8133342 49.65025,21.636 C50.0142518,21.4586658 50.3969147,21.37 50.79825,21.37 C51.6195874,21.37 52.2659143,21.6149976 52.73725,22.105 C53.2085857,22.5950024 53.44425,23.2739957 53.44425,24.142 L53.44425,29 L51.86225,29 L51.86225,24.562 C51.86225,23.4139943 51.3815881,22.84 50.42025,22.84 C49.9349142,22.84 49.5475848,22.9799986 49.25825,23.26 C48.9689152,23.5400014 48.82425,23.9179976 48.82425,24.394 L48.82425,29 L47.22825,29 Z M60.621,26.536 L61.769,27.474 C61.0503297,28.6313391 60.0236733,29.21 58.689,29.21 C57.6623282,29.21 56.8246699,28.8530036 56.176,28.139 C55.5273301,27.4249964 55.203,26.4753393 55.203,25.29 C55.203,24.1046607 55.5249968,23.1550036 56.169,22.441 C56.8130032,21.7269964 57.6296617,21.37 58.619,21.37 C59.6083383,21.37 60.4179968,21.7246631 61.048,22.434 C61.6780031,23.1433369 61.993,24.0953274 61.993,25.29 L61.993,25.766 L56.813,25.766 C56.8316668,26.3820031 57.0019984,26.8743315 57.324,27.243 C57.6460016,27.6116685 58.0916638,27.796 58.661,27.796 C58.931668,27.796 59.1743323,27.758667 59.389,27.684 C59.6036677,27.609333 59.7926658,27.4973341 59.956,27.348 C60.1193342,27.1986659 60.2429996,27.0680006 60.327,26.956 C60.4110004,26.8439994 60.5089994,26.7040008 60.621,26.536 L60.621,26.536 Z M56.827,24.562 L60.439,24.562 C60.4109999,24.0393307 60.2430015,23.612335 59.935,23.281 C59.6269985,22.949665 59.1883362,22.784 58.619,22.784 C58.0869973,22.784 57.6623349,22.9613316 57.345,23.316 C57.0276651,23.6706684 56.8550001,24.0859976 56.827,24.562 L56.827,24.562 Z M68.32975,26.046 L69.91175,26.382 C69.7624159,27.2780045 69.4217527,27.9733309 68.88975,28.468 C68.3577473,28.9626691 67.6530877,29.21 66.77575,29.21 C65.767745,29.21 64.9417532,28.8646701 64.29775,28.174 C63.6537468,27.4833299 63.33175,26.5220062 63.33175,25.29 C63.33175,24.1046607 63.6560801,23.1550036 64.30475,22.441 C64.9534199,21.7269964 65.7724117,21.37 66.76175,21.37 C67.6110876,21.37 68.3110806,21.6243308 68.86175,22.133 C69.4124194,22.6416692 69.7344162,23.3019959 69.82775,24.114 L68.32975,24.366 C68.1710825,23.3299948 67.6530877,22.812 66.77575,22.812 C66.2064138,22.812 65.7537517,23.0289978 65.41775,23.463 C65.0817483,23.8970022 64.91375,24.5059961 64.91375,25.29 C64.91375,26.0740039 65.0770817,26.6829978 65.40375,27.117 C65.7304183,27.5510022 66.1877471,27.768 66.77575,27.768 C67.6437543,27.768 68.1617492,27.1940057 68.32975,26.046 L68.32975,26.046 Z M72.0205,26.522 L72.0205,22.952 L70.9005,22.952 L70.9005,21.58 L72.0625,21.58 L72.0625,19.76 L73.5745,19.76 L73.5745,21.58 L75.4365,21.58 L75.4365,22.952 L73.5885,22.952 L73.5885,26.354 C73.5885,26.7646687 73.6514994,27.0516658 73.7775,27.215 C73.9035006,27.3783342 74.162498,27.46 74.5545,27.46 L75.1425,27.46 L75.1425,29 L74.4285,29 C73.5324955,29 72.9071684,28.8016686 72.5525,28.405 C72.1978316,28.0083313 72.0205,27.380671 72.0205,26.522 L72.0205,26.522 Z M81.992,29 L80.354,21.58 L81.922,21.58 L82.972,26.746 L83,26.746 L84.764,21.58 L86.206,21.58 L87.858,26.732 L87.886,26.732 L89.076,21.58 L90.616,21.58 L88.838,29 L87.298,29 L85.492,23.428 L85.464,23.428 L83.518,29 L81.992,29 Z M92.40275,29 L92.40275,21.58 L93.99875,21.58 L93.99875,29 L92.40275,29 Z M92.37475,20.362 L92.37475,18.78 L94.02675,18.78 L94.02675,20.362 L92.37475,20.362 Z M96.6955,26.522 L96.6955,22.952 L95.5755,22.952 L95.5755,21.58 L96.7375,21.58 L96.7375,19.76 L98.2495,19.76 L98.2495,21.58 L100.1115,21.58 L100.1115,22.952 L98.2635,22.952 L98.2635,26.354 C98.2635,26.7646687 98.3264994,27.0516658 98.4525,27.215 C98.5785006,27.3783342 98.837498,27.46 99.2295,27.46 L99.8175,27.46 L99.8175,29 L99.1035,29 C98.2074955,29 97.5821684,28.8016686 97.2275,28.405 C96.8728316,28.0083313 96.6955,27.380671 96.6955,26.522 L96.6955,26.522 Z M101.87025,29 L101.87025,18.78 L103.46625,18.78 L103.46625,22.308 L103.49425,22.308 C103.662251,22.0559987 103.937581,21.8366676 104.32025,21.65 C104.702919,21.4633324 105.090248,21.37 105.48225,21.37 C106.275587,21.37 106.919581,21.6126642 107.41425,22.098 C107.908919,22.5833358 108.15625,23.2459958 108.15625,24.086 L108.15625,29 L106.57425,29 L106.57425,24.464 C106.57425,23.9786642 106.443585,23.5866682 106.18225,23.288 C105.920915,22.9893318 105.542919,22.84 105.04825,22.84 C104.572248,22.84 104.189585,22.9799986 103.90025,23.26 C103.610915,23.5400014 103.46625,23.8993311 103.46625,24.338 L103.46625,29 L101.87025,29 Z" id="Connect-with" fill="#FFFFFF"></path>
11 |             <path d="M160.015559,18.7243818 L157.573637,23.6936411 L155.130184,18.7243818 L151.538762,18.7243818 L157.573637,31 L163.604197,18.7243818 L160.015559,18.7243818 Z M140.167341,23.0633572 C140.167341,22.6899778 140.038474,22.4112701 139.782411,22.2312505 C139.527323,22.049653 139.178854,21.959428 138.742573,21.959428 L137.108085,21.959428 L137.108085,24.220073 L138.726013,24.220073 C139.17454,24.220073 139.527323,24.1208112 139.782411,23.9228613 C140.038474,23.7244811 140.167341,23.4484988 140.167341,23.0966357 L140.167341,23.0633572 Z M149.175468,18 L155.208534,30.2756182 L151.617112,30.2756182 L149.175468,25.306072 L146.735216,30.2756182 L144.297747,30.2756182 L143.145603,30.2756182 L140.022749,30.2756182 L137.908281,26.9753059 L137.877804,26.9753059 L137.108085,26.9753059 L137.108085,30.2756182 L133.360798,30.2756182 L133.360798,18.7243818 L138.838458,18.7243818 C139.841696,18.7243818 140.666246,18.8428649 141.311553,19.0794006 C141.958668,19.3155061 142.477752,19.638107 142.87298,20.0451952 C143.215325,20.3961977 143.471249,20.7933884 143.642978,21.231747 C143.812619,21.6721138 143.898902,22.1909433 143.898902,22.7824979 L143.898902,22.8174977 C143.898902,23.6638052 143.701288,24.3792936 143.305086,24.9618113 C142.911389,25.5449028 142.372405,26.0083638 141.687715,26.3481777 L143.635324,29.2788401 L149.175468,18 Z M165.966934,18 L159.934565,30.2756182 L163.525987,30.2756182 L165.966934,25.306072 L168.409552,30.2756182 L172,30.2756182 L165.966934,18 Z M122.487587,21.9899811 L125.786345,21.9899811 L125.786345,30.2756182 L129.534327,30.2756182 L129.534327,21.9899811 L132.833921,21.9899811 L132.833921,18.7243818 L122.487587,18.7243818 L122.487587,21.9899811 Z M122.352597,25.0606428 C122.581523,25.4677311 122.696612,25.9636099 122.696612,26.5455539 L122.696612,26.5794062 C122.696612,27.1838705 122.579853,27.7295237 122.343829,28.212923 C122.109615,28.6976133 121.777847,29.1069967 121.351168,29.4430811 C120.923515,29.7780181 120.405405,30.036357 119.797395,30.2182414 C119.189663,30.400843 118.505112,30.4919286 117.748474,30.4919286 C116.606767,30.4919286 115.540905,30.3282614 114.553254,30.0046563 C113.565741,29.6791866 112.715028,29.1923446 112,28.5447042 L114.001188,26.0865396 C114.609059,26.5697955 115.250886,26.9167816 115.922216,27.1254896 C116.594521,27.334628 117.262511,27.4391972 117.924378,27.4391972 C118.266584,27.4391972 118.511235,27.3947302 118.660976,27.3078043 C118.811692,27.2194441 118.884892,27.0980922 118.884892,26.9447528 L118.884892,26.9119046 C118.884892,26.7453685 118.774256,26.6062298 118.556603,26.4980746 C118.338949,26.388198 117.928692,26.273301 117.331258,26.1525229 C116.701677,26.0195522 116.100764,25.8647784 115.530329,25.6893489 C114.959058,25.51478 114.457508,25.2881418 114.025541,25.0125898 C113.592878,24.7383288 113.248863,24.3904821 112.991966,23.9727791 C112.735903,23.554359 112.607871,23.0422712 112.607871,22.4378069 L112.607871,22.4045284 C112.607871,21.8538547 112.711549,21.341767 112.920435,20.8692692 C113.126816,20.3961977 113.431726,19.982798 113.832242,19.6317956 C114.232897,19.2795021 114.730132,19.0049543 115.323112,18.80557 C115.913588,18.6076201 116.594521,18.508932 117.364379,18.508932 C118.45209,18.508932 119.404811,18.6413289 120.221569,18.9062662 C121.038465,19.1683346 121.771724,19.5649516 122.423988,20.092818 L120.598705,22.7013097 C120.064869,22.3039755 119.501531,22.0153704 118.909246,21.8333425 C118.315431,21.6514581 117.759746,21.5603725 117.235513,21.5603725 C116.958575,21.5603725 116.753168,21.6044092 116.619849,21.6927694 C116.484024,21.7808428 116.419591,21.8968873 116.419591,22.0391817 L116.419591,22.0720299 C116.419591,22.2273776 116.51965,22.3593441 116.723526,22.469651 C116.927263,22.5790972 117.321656,22.6949983 117.907817,22.8160633 C118.623541,22.9471692 119.274136,23.1073939 119.862802,23.2932946 C120.448825,23.4822077 120.954827,23.7204648 121.375383,24.012656 C121.797052,24.3042735 122.123532,24.6521202 122.352597,25.0606428 L122.352597,25.0606428 Z" id="Strava-logo-Copy-6" fill="#FFFFFF"></path>
12 |         </g>
13 |     </g>
14 | </svg>


--------------------------------------------------------------------------------
/src/img/strava_logo.svg:
--------------------------------------------------------------------------------
1 | <svg viewBox="0 0 16 16" xmlns="http://www.w3.org/2000/svg" width="2500" height="2500"><path d="M0 0h16v16H0z" fill="#fc4c02"/><g fill="#fff" fill-rule="evenodd"><path d="M6.9 8.8l2.5 4.5 2.4-4.5h-1.5l-.9 1.7-1-1.7z" opacity=".6"/><path d="M7.2 2.5l3.1 6.3H4zm0 3.8l1.2 2.5H5.9z"/></g></svg>


--------------------------------------------------------------------------------
/src/module.tsx:
--------------------------------------------------------------------------------
 1 | import { DataSourcePlugin } from '@grafana/data';
 2 | import { StravaVariableQueryEditor } from './components/VariableQueryEditor';
 3 | import { ConfigEditor } from './components/ConfigEditor';
 4 | import { QueryEditor } from './components/QueryEditor';
 5 | import StravaDatasource from './datasource';
 6 | import { StravaJsonData, StravaQuery, StravaSecureJsonData } from './types';
 7 | 
 8 | export const plugin = new DataSourcePlugin<StravaDatasource, StravaQuery, StravaJsonData, StravaSecureJsonData>(
 9 |   StravaDatasource
10 | )
11 |   .setConfigEditor(ConfigEditor)
12 |   .setQueryEditor(QueryEditor)
13 |   .setVariableQueryEditor(StravaVariableQueryEditor);
14 | 


--------------------------------------------------------------------------------
/src/plugin.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "Strava",
 3 |   "id": "grafana-strava-datasource",
 4 |   "type": "datasource",
 5 |   "metrics": true,
 6 |   "annotations": false,
 7 |   "backend": true,
 8 |   "alerting": false,
 9 |   "executable": "gpx_strava",
10 |   "info": {
11 |     "description": "Strava datasource",
12 |     "author": {
13 |       "name": "Grafana Labs",
14 |       "url": "https://grafana.com"
15 |     },
16 |     "logos": {
17 |       "small": "img/strava_logo.svg",
18 |       "large": "img/strava_logo.svg"
19 |     },
20 |     "links": [
21 |       {
22 |         "name": "Website",
23 |         "url": "https://grafana.com/plugins/grafana-strava-datasource"
24 |       },
25 |       {
26 |         "name": "License",
27 |         "url": "https://grafana.com/plugins/grafana-strava-datasource/license"
28 |       }
29 |     ],
30 |     "version": "%VERSION%",
31 |     "updated": "%TODAY%"
32 |   },
33 |   "includes": [
34 |     {
35 |       "type": "dashboard",
36 |       "name": "Strava Athlete Dashboard",
37 |       "path": "dashboards/strava_athlete_dashboard.json"
38 |     },
39 |     {
40 |       "type": "dashboard",
41 |       "name": "Strava Datasource",
42 |       "path": "dashboards/strava_datasource.json"
43 |     },
44 |     {
45 |       "type": "dashboard",
46 |       "name": "Strava Activity Analysis",
47 |       "path": "dashboards/strava_activity_analysis.json"
48 |     },
49 |     {
50 |       "type": "dashboard",
51 |       "name": "Strava Activity Overview",
52 |       "path": "dashboards/strava_activity_overview.json"
53 |     },
54 |     {
55 |       "type": "dashboard",
56 |       "name": "Strava Segment Overview",
57 |       "path": "dashboards/strava_segment_overview.json"
58 |     }
59 |   ],
60 |   "dependencies": {
61 |     "grafanaDependency": ">=10.3.0",
62 |     "grafanaVersion": "10.3.0",
63 |     "plugins": []
64 |   },
65 |   "iam": {
66 |     "permissions": [
67 |       {
68 |         "action": "datasources:write",
69 |         "scope": "datasources:uid:*"
70 |       },
71 |       {
72 |         "action": "datasources:read",
73 |         "scope": "datasources:uid:*"
74 |       }
75 |     ]
76 |   }
77 | }
78 | 


--------------------------------------------------------------------------------
/src/polyline.ts:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * This file contains code from google-polyline
 3 |  * https://github.com/jhermsmeier/node-google-polyline
 4 |  *
 5 |  * https://github.com/jhermsmeier/node-google-polyline/blob/master/lib/decode.js
 6 |  */
 7 | 
 8 | const PRECISION = 1e5;
 9 | 
10 | export function decode(value: any) {
11 |   let points: any[] = [];
12 |   let lat = 0;
13 |   let lon = 0;
14 | 
15 |   integers(value, function (x: number, y: number) {
16 |     lat += x;
17 |     lon += y;
18 |     points.push([lat / PRECISION, lon / PRECISION]);
19 |   });
20 | 
21 |   return points;
22 | }
23 | 
24 | export function sign(value: any) {
25 |   return value & 1 ? ~(value >>> 1) : value >>> 1;
26 | }
27 | 
28 | export function integers(value: any, callback: any) {
29 |   let values = 0;
30 |   let x = 0;
31 |   let y = 0;
32 | 
33 |   let byte = 0;
34 |   let current = 0;
35 |   let bits = 0;
36 | 
37 |   for (let i = 0; i < value.length; i++) {
38 |     byte = value.charCodeAt(i) - 63;
39 |     current = current | ((byte & 0x1f) << bits);
40 |     bits = bits + 5;
41 | 
42 |     if (byte < 0x20) {
43 |       if (++values & 1) {
44 |         x = sign(current);
45 |       } else {
46 |         y = sign(current);
47 |         callback(x, y);
48 |       }
49 |       current = 0;
50 |       bits = 0;
51 |     }
52 |   }
53 | 
54 |   return values;
55 | }
56 | 
57 | export default {
58 |   decode,
59 | };
60 | 


--------------------------------------------------------------------------------
/src/responseHandler.ts:
--------------------------------------------------------------------------------
  1 | import {
  2 |   TimeRange,
  3 |   DataFrame,
  4 |   dateTime,
  5 |   MutableField,
  6 |   TIME_SERIES_TIME_FIELD_NAME,
  7 |   FieldType,
  8 |   TIME_SERIES_VALUE_FIELD_NAME,
  9 |   MutableDataFrame,
 10 |   TimeSeriesPoints,
 11 |   TimeSeriesValue,
 12 | } from '@grafana/data';
 13 | import polyline from 'polyline';
 14 | import {
 15 |   StravaActivity,
 16 |   StravaQuery,
 17 |   StravaQueryInterval,
 18 |   StravaMeasurementPreference,
 19 |   StravaActivityStat,
 20 | } from 'types';
 21 | import {
 22 |   INTERVAL_1w,
 23 |   INTERVAL_4w,
 24 |   getAggregationInterval,
 25 |   getAggregationIntervalFromTarget,
 26 |   getPreferredDistance,
 27 |   getPreferredLength,
 28 | } from 'utils';
 29 | 
 30 | interface TransformOptions {
 31 |   measurementPreference: StravaMeasurementPreference;
 32 | }
 33 | 
 34 | export function transformActivitiesToTimeseries(
 35 |   activities: StravaActivity[],
 36 |   target: StravaQuery,
 37 |   range: TimeRange,
 38 |   options: TransformOptions
 39 | ): DataFrame {
 40 |   const { measurementPreference } = options;
 41 |   let datapoints: any[] = [];
 42 |   for (const activity of activities) {
 43 |     const statValue = getActivityStat(activity, target.activityStat, measurementPreference);
 44 |     datapoints.push([statValue, dateTime(activity.start_date).valueOf()]);
 45 |   }
 46 |   datapoints.sort((dpA, dpB) => dpA[1] - dpB[1]);
 47 | 
 48 |   if (target.interval !== StravaQueryInterval.No) {
 49 |     const aggInterval =
 50 |       !target.interval || target.interval === StravaQueryInterval.Auto
 51 |         ? getAggregationInterval(range)
 52 |         : getAggregationIntervalFromTarget(target);
 53 |     if (aggInterval >= INTERVAL_4w) {
 54 |       datapoints = groupByMonthSum(datapoints, range);
 55 |     } else if (aggInterval === INTERVAL_1w) {
 56 |       datapoints = groupByWeekSum(datapoints, range);
 57 |     } else {
 58 |       datapoints = groupBySum(datapoints, range, aggInterval);
 59 |     }
 60 |   }
 61 | 
 62 |   const timeFiled: MutableField<number> = {
 63 |     name: TIME_SERIES_TIME_FIELD_NAME,
 64 |     type: FieldType.time,
 65 |     config: {},
 66 |     values: [],
 67 |   };
 68 | 
 69 |   const valueFiled: MutableField<number> = {
 70 |     name: TIME_SERIES_VALUE_FIELD_NAME,
 71 |     type: FieldType.number,
 72 |     config: {
 73 |       unit: getStatUnit(target.activityStat, measurementPreference),
 74 |     },
 75 |     values: [],
 76 |   };
 77 | 
 78 |   for (let i = 0; i < datapoints.length; i++) {
 79 |     const dp = datapoints[i];
 80 |     timeFiled.values.add(dp[1]);
 81 |     valueFiled.values.add(dp[0]);
 82 |   }
 83 | 
 84 |   const alias = `${target.activityType ? target.activityType + '_' : ''}${target.activityStat}`;
 85 |   return new MutableDataFrame({
 86 |     name: alias,
 87 |     refId: target.refId,
 88 |     fields: [timeFiled, valueFiled],
 89 |   });
 90 | }
 91 | 
 92 | export function transformActivitiesToTable(
 93 |   activities: StravaActivity[],
 94 |   target: StravaQuery,
 95 |   options: TransformOptions
 96 | ) {
 97 |   const { measurementPreference } = options;
 98 |   const distanceUnit = measurementPreference === StravaMeasurementPreference.Feet ? 'lengthmi' : 'lengthm';
 99 |   const lengthUnit = measurementPreference === StravaMeasurementPreference.Feet ? 'lengthft' : 'lengthm';
100 | 
101 |   const frame = new MutableDataFrame({
102 |     refId: target.refId,
103 |     fields: [
104 |       { name: 'time', type: FieldType.time },
105 |       { name: 'name', type: FieldType.string },
106 |       { name: 'distance', type: FieldType.number, config: { unit: distanceUnit } },
107 |       { name: 'moving time', type: FieldType.number, config: { unit: 'dthms' } },
108 |       { name: 'elapsed time', type: FieldType.number, config: { unit: 'dthms' } },
109 |       { name: 'heart rate', type: FieldType.number, config: { unit: 'none', decimals: 0 } },
110 |       { name: 'elevation gain', type: FieldType.number, config: { unit: lengthUnit, decimals: 0 } },
111 |       { name: 'kilojoules', type: FieldType.number, config: { unit: 'joule' } },
112 |       { name: 'type', type: FieldType.string },
113 |       { name: 'id', type: FieldType.string, config: { unit: 'none', custom: { hidden: true } } },
114 |       { name: 'time_from', type: FieldType.number, config: { unit: 'none', decimals: 0, custom: { hidden: true } } },
115 |       { name: 'time_to', type: FieldType.number, config: { unit: 'none', decimals: 0, custom: { hidden: true } } },
116 |     ],
117 |   });
118 | 
119 |   target.extendedStats?.forEach((stat) => {
120 |     frame.addField({ name: stat });
121 |   });
122 | 
123 |   for (let i = 0; i < activities.length; i++) {
124 |     const activity = activities[i];
125 |     const dataRow: any = {
126 |       time: dateTime(activity.start_date),
127 |       name: activity.name,
128 |       distance: getPreferredDistance(activity.distance, measurementPreference),
129 |       'moving time': activity.moving_time,
130 |       'elapsed time': activity.elapsed_time,
131 |       'heart rate': activity.average_heartrate,
132 |       'elevation gain': getPreferredLength(activity.total_elevation_gain, measurementPreference),
133 |       kilojoules: activity.kilojoules,
134 |       type: activity.sport_type,
135 |       id: activity.id,
136 |       time_from: dateTime(activity.start_date).unix() * 1000,
137 |       time_to: (dateTime(activity.start_date).unix() + activity.elapsed_time) * 1000,
138 |     };
139 |     target.extendedStats?.forEach((stat) => {
140 |       const statValue = (activity as any)[stat];
141 |       if (statValue) {
142 |         dataRow[stat] = statValue;
143 |       }
144 |     });
145 |     frame.add(dataRow);
146 |   }
147 |   return frame;
148 | }
149 | 
150 | export function transformActivitiesToGeomap(
151 |   activities: StravaActivity[],
152 |   target: StravaQuery,
153 |   options: TransformOptions
154 | ) {
155 |   const { measurementPreference } = options;
156 |   const frame = new MutableDataFrame({
157 |     name: 'activities',
158 |     refId: target.refId,
159 |     fields: [
160 |       { name: 'name', type: FieldType.string },
161 |       { name: 'latitude', type: FieldType.number },
162 |       { name: 'longitude', type: FieldType.number },
163 |       {
164 |         name: 'value',
165 |         type: FieldType.number,
166 |         config: {
167 |           unit: getStatUnit(target.activityStat, measurementPreference),
168 |         },
169 |       },
170 |       { name: 'time', type: FieldType.time },
171 |       { name: 'id', type: FieldType.string, config: { unit: 'none', custom: { hidden: true } } },
172 |       { name: 'time_from', type: FieldType.number, config: { unit: 'none', decimals: 0, custom: { hidden: true } } },
173 |       { name: 'time_to', type: FieldType.number, config: { unit: 'none', decimals: 0, custom: { hidden: true } } },
174 |     ],
175 |   });
176 | 
177 |   for (const activity of activities) {
178 |     const middlePoint = getActivityMiddlePoint(activity);
179 |     const latitude = middlePoint ? middlePoint[0] : activity.start_latlng[0];
180 |     const longitude = middlePoint ? middlePoint[1] : activity.start_latlng[1];
181 |     if (latitude && longitude) {
182 |       frame.add({
183 |         name: activity.name,
184 |         value: getActivityStat(activity, target.activityStat, measurementPreference),
185 |         latitude,
186 |         longitude,
187 |         time: dateTime(activity.start_date),
188 |         id: activity.id,
189 |         time_from: dateTime(activity.start_date).unix() * 1000,
190 |         time_to: (dateTime(activity.start_date).unix() + activity.elapsed_time) * 1000,
191 |       });
192 |     }
193 |   }
194 |   return frame;
195 | }
196 | 
197 | export function transformActivitiesToHeatmap(
198 |   activities: StravaActivity[],
199 |   target: StravaQuery,
200 |   options: TransformOptions
201 | ) {
202 |   const frame = new MutableDataFrame({
203 |     name: 'heatmap',
204 |     refId: target.refId,
205 |     fields: [
206 |       { name: 'latitude', type: FieldType.number },
207 |       { name: 'longitude', type: FieldType.number },
208 |       { name: 'value', type: FieldType.number },
209 |     ],
210 |   });
211 | 
212 |   for (const activity of activities) {
213 |     const summaryPolyline = activity?.map?.summary_polyline;
214 |     if (summaryPolyline) {
215 |       const points = polyline.decode(summaryPolyline);
216 |       for (let i = 0; i < points.length; i++) {
217 |         frame.add({
218 |           latitude: points[i][0],
219 |           longitude: points[i][1],
220 |           value: 1,
221 |         });
222 |       }
223 |     }
224 |   }
225 |   return frame;
226 | }
227 | 
228 | function getActivityStat(
229 |   activity: StravaActivity,
230 |   activityStat: StravaActivityStat,
231 |   measurementPreference: StravaMeasurementPreference
232 | ) {
233 |   if (activityStat === StravaActivityStat.Distance) {
234 |     return getPreferredDistance(activity.distance, measurementPreference);
235 |   } else if (activityStat === StravaActivityStat.ElevationGain) {
236 |     return getPreferredLength(activity.total_elevation_gain, measurementPreference);
237 |   } else {
238 |     return activity[activityStat];
239 |   }
240 | }
241 | 
242 | function getActivityMiddlePoint(activity: any): number[] | null {
243 |   if (!activity.map || !activity.map.summary_polyline) {
244 |     return null;
245 |   }
246 | 
247 |   const summaryPolyline = activity.map.summary_polyline;
248 |   const points = polyline.decode(summaryPolyline);
249 |   if (points && points.length) {
250 |     const middleIndex = Math.floor(points.length / 2);
251 |     return points[middleIndex];
252 |   } else {
253 |     return null;
254 |   }
255 | }
256 | 
257 | function getStatUnit(activityStat: StravaActivityStat, measurementPreference: StravaMeasurementPreference): string {
258 |   if (activityStat === StravaActivityStat.Distance) {
259 |     return measurementPreference === StravaMeasurementPreference.Feet ? 'lengthmi' : 'lengthm';
260 |   }
261 |   if (activityStat === StravaActivityStat.ElevationGain) {
262 |     return measurementPreference === StravaMeasurementPreference.Feet ? 'lengthft' : 'lengthm';
263 |   }
264 |   if (activityStat === StravaActivityStat.ElapsedTime || activityStat === StravaActivityStat.MovingTime) {
265 |     return 'dthms';
266 |   }
267 |   if (activityStat === StravaActivityStat.AveragePower) {
268 |     return 'watt';
269 |   }
270 |   return 'none';
271 | }
272 | 
273 | export function groupBySum(datapoints: TimeSeriesPoints, range: TimeRange, interval: number): TimeSeriesPoints {
274 |   return groupByTime(datapoints, range, interval, getPointTimeFrame, getNextTimeFrame, AGG_SUM);
275 | }
276 | 
277 | export function groupByWeekSum(datapoints: TimeSeriesPoints, range: TimeRange): TimeSeriesPoints {
278 |   return groupByTime(datapoints, range, null, getClosestWeek, getNextWeek, AGG_SUM);
279 | }
280 | 
281 | export function groupByMonthSum(datapoints: TimeSeriesPoints, range: TimeRange): TimeSeriesPoints {
282 |   return groupByTime(datapoints, range, null, getClosestMonth, getNextMonth, AGG_SUM);
283 | }
284 | 
285 | const POINT_VALUE = 0;
286 | const POINT_TIMESTAMP = 1;
287 | 
288 | export function groupByTime(
289 |   datapoints: any[],
290 |   range: TimeRange,
291 |   interval: number | null,
292 |   intervalFn: any,
293 |   nextIntervalFn: any,
294 |   groupByFn: any
295 | ): any[] {
296 |   if (datapoints.length === 0) {
297 |     return [];
298 |   }
299 | 
300 |   const time_from = range.from.unix() * 1000;
301 |   const time_to = range.to.unix() * 1000;
302 |   let grouped_series: any[] = [];
303 |   let frame_values: any[] = [];
304 |   let frame_value;
305 |   let frame_ts = datapoints.length ? intervalFn(time_from, interval) : 0;
306 |   let point_frame_ts = frame_ts;
307 |   let point;
308 | 
309 |   for (let i = 0; i < datapoints.length; i++) {
310 |     point = datapoints[i];
311 |     point_frame_ts = intervalFn(point[POINT_TIMESTAMP], interval);
312 |     if (point_frame_ts === frame_ts) {
313 |       frame_values.push(point[POINT_VALUE]);
314 |     } else if (point_frame_ts > frame_ts) {
315 |       frame_value = frame_values.length ? groupByFn(frame_values) : null;
316 |       grouped_series.push([frame_value, frame_ts]);
317 | 
318 |       // Move frame window to next non-empty interval and fill empty by null
319 |       frame_ts = nextIntervalFn(frame_ts, interval);
320 |       while (frame_ts < point_frame_ts) {
321 |         grouped_series.push([null, frame_ts]);
322 |         frame_ts = nextIntervalFn(frame_ts, interval);
323 |       }
324 |       frame_values = [point[POINT_VALUE]];
325 |     }
326 |   }
327 | 
328 |   frame_value = groupByFn(frame_values);
329 |   grouped_series.push([frame_value, frame_ts]);
330 | 
331 |   // Move frame window to end of time range and fill empty by null
332 |   frame_ts = nextIntervalFn(frame_ts, interval);
333 |   while (frame_ts < time_to) {
334 |     grouped_series.push([null, frame_ts]);
335 |     frame_ts = nextIntervalFn(frame_ts, interval);
336 |   }
337 | 
338 |   return grouped_series;
339 | }
340 | 
341 | const AGG_SUM = (values: TimeSeriesValue[]) => {
342 |   return values.reduce((acc, val) => acc! + val!);
343 | };
344 | 
345 | function getPointTimeFrame(timestamp: any, ms_interval: any) {
346 |   return Math.floor(timestamp / ms_interval) * ms_interval;
347 | }
348 | 
349 | function getNextTimeFrame(timestamp: any, ms_interval: any) {
350 |   return timestamp + ms_interval;
351 | }
352 | 
353 | function getClosestMonth(timestamp: any): number {
354 |   const month_time = dateTime(timestamp).startOf('month');
355 |   return month_time.unix() * 1000;
356 | }
357 | 
358 | function getNextMonth(timestamp: any): number {
359 |   const next_month_time = dateTime(timestamp).add(1, 'month');
360 |   return next_month_time.unix() * 1000;
361 | }
362 | 
363 | function getClosestWeek(timestamp: any): number {
364 |   // The first Monday after the Unix Epoch begins on Jan 5, 1970, 00:00.
365 |   // This is a UNIX timestamp of 96 hours or 345600000 ms
366 |   const FIRST_MONDAY_MS = 345600000;
367 |   const week_ts = timestamp - FIRST_MONDAY_MS;
368 |   return Math.floor(week_ts / INTERVAL_1w) * INTERVAL_1w + FIRST_MONDAY_MS;
369 | }
370 | 
371 | function getNextWeek(timestamp: any): number {
372 |   return timestamp + INTERVAL_1w;
373 | }
374 | 


--------------------------------------------------------------------------------
/src/stravaApi.ts:
--------------------------------------------------------------------------------
  1 | import { getBackendSrv } from '@grafana/runtime';
  2 | import { DataStreamSet, Segment, StravaActivity, StravaAthlete, StreamType } from 'types';
  3 | 
  4 | export default class StravaApi {
  5 |   datasourceId: number;
  6 |   backendAPIUrl: string;
  7 |   backendAuthUrl: string;
  8 |   apiUrl: string;
  9 |   promises: any;
 10 | 
 11 |   constructor(datasourceId: number) {
 12 |     this.datasourceId = datasourceId;
 13 |     this.backendAPIUrl = `/api/datasources/${this.datasourceId}/resources/strava-api`;
 14 |     this.backendAuthUrl = `/api/datasources/${this.datasourceId}/resources/auth`;
 15 | 
 16 |     // this.apiUrl = url;
 17 |     this.promises = {};
 18 |     this.apiUrl = '';
 19 |   }
 20 | 
 21 |   async getAuthenticatedAthlete(): Promise<StravaAthlete> {
 22 |     return await this.tsdbRequest('athlete');
 23 |   }
 24 | 
 25 |   async getActivities(params?: any): Promise<StravaActivity[]> {
 26 |     return await this.requestWithPagination('athlete/activities', params);
 27 |   }
 28 | 
 29 |   async getActivity(params?: any): Promise<StravaActivity> {
 30 |     const { id, include_all_efforts } = params;
 31 |     return await this.tsdbRequest(`/activities/${id}`, { include_all_efforts });
 32 |   }
 33 | 
 34 |   async getActivityStreams(params: { id: number | string; streamTypes: StreamType[] }): Promise<DataStreamSet<any>> {
 35 |     const { id, streamTypes } = params;
 36 |     const streams = streamTypes.join(',');
 37 |     return await this.tsdbRequest(`/activities/${id}/streams`, {
 38 |       key_by_type: true,
 39 |       keys: `${streams},time`,
 40 |     });
 41 |   }
 42 | 
 43 |   async getSegment(id: number): Promise<Segment> {
 44 |     return await this.tsdbRequest(`/segments/${id}`);
 45 |   }
 46 | 
 47 |   async requestWithPagination(url: string, params?: any) {
 48 |     let data: any[] = [];
 49 |     let chunk = [];
 50 |     let page = 1;
 51 |     const limit = params && params.limit;
 52 |     let per_page = (params && params.per_page) || 200;
 53 |     if (limit) {
 54 |       per_page = Math.min(per_page, limit);
 55 |     }
 56 | 
 57 |     while (!(chunk.length === 0 && page !== 1) && !(limit && data.length >= limit)) {
 58 |       params = {
 59 |         ...params,
 60 |         per_page,
 61 |         page,
 62 |       };
 63 |       try {
 64 |         // chunk = await this.request(url, params);
 65 |         chunk = await this.tsdbRequest(url, params);
 66 |       } catch (error) {
 67 |         throw error;
 68 |       }
 69 |       data = data.concat(chunk);
 70 |       page++;
 71 |     }
 72 |     return data;
 73 |   }
 74 | 
 75 |   async exchangeToken(authCode: any) {
 76 |     return await this.tsdbAuthRequest({ authCode });
 77 |   }
 78 | 
 79 |   async resetAccessToken() {
 80 |     try {
 81 |       const response = await getBackendSrv().get(`/api/datasources/${this.datasourceId}/resources/reset-access-token`);
 82 |       return this.handleTsdbResponse(response);
 83 |     } catch (error) {
 84 |       console.log(error);
 85 |       throw error;
 86 |     }
 87 |   }
 88 | 
 89 |   async resetCache() {
 90 |     try {
 91 |       const response = await getBackendSrv().get(`/api/datasources/${this.datasourceId}/resources/reset-cache`);
 92 |       return this.handleTsdbResponse(response);
 93 |     } catch (error) {
 94 |       console.log(error);
 95 |       throw error;
 96 |     }
 97 |   }
 98 | 
 99 |   async request(url: string, params?: any) {
100 |     return this.proxyfy(this._request, '_request', this)(url, params);
101 |   }
102 | 
103 |   async _request(url: string, params?: any) {
104 |     try {
105 |       const response = await getBackendSrv().datasourceRequest({
106 |         url: `${this.apiUrl}/strava/${url}`,
107 |         method: 'GET',
108 |         params,
109 |       });
110 |       return response.data;
111 |     } catch (error) {
112 |       console.log(error);
113 |       throw error;
114 |     }
115 |   }
116 | 
117 |   async tsdbRequest(endpoint: string, params?: any) {
118 |     return this.proxyfy(this._tsdbRequest, '_tsdbRequest', this)(endpoint, params);
119 |   }
120 | 
121 |   async _tsdbRequest(endpoint: string, params?: any) {
122 |     try {
123 |       const response = await getBackendSrv().datasourceRequest({
124 |         url: this.backendAPIUrl,
125 |         method: 'POST',
126 |         headers: {
127 |           'Content-Type': 'application/json',
128 |         },
129 |         data: {
130 |           datasourceId: this.datasourceId,
131 |           endpoint,
132 |           params,
133 |         },
134 |       });
135 |       return this.handleTsdbResponse(response);
136 |     } catch (error) {
137 |       console.log(error);
138 |       throw error;
139 |     }
140 |   }
141 | 
142 |   async tsdbAuthRequest(params?: any) {
143 |     const queryType = 'stravaAuth';
144 | 
145 |     try {
146 |       const response = await getBackendSrv().datasourceRequest({
147 |         url: this.backendAuthUrl,
148 |         method: 'POST',
149 |         data: params,
150 |       });
151 |       return this.handleTsdbResponse(response, queryType);
152 |     } catch (error) {
153 |       console.log(error);
154 |       throw error;
155 |     }
156 |   }
157 | 
158 |   handleTsdbResponse(response: any, queryType = 'stravaAPI') {
159 |     if (response && (response.status >= 400 || response.status < 0)) {
160 |       throw Error(response.statusText);
161 |     }
162 | 
163 |     if (!response || !response.data || !response.data.result) {
164 |       return [];
165 |     }
166 | 
167 |     const responseData = response.data.result;
168 |     if (responseData.error) {
169 |       throw Error(responseData.error);
170 |     }
171 | 
172 |     return responseData;
173 |   }
174 | 
175 |   proxyfy(func: any, funcName: any, funcScope: any) {
176 |     if (!this.promises[funcName]) {
177 |       this.promises[funcName] = {};
178 |     }
179 |     const promiseKeeper = this.promises[funcName];
180 |     return callOnce(func, promiseKeeper, funcScope);
181 |   }
182 | }
183 | 
184 | /**
185 |  * Wrap request to prevent multiple calls
186 |  * with same params when waiting for result.
187 |  */
188 | function callOnce(func: any, promiseKeeper: any, funcScope: any): (...args: any[]) => any {
189 |   return function () {
190 |     let hash = getRequestHash(arguments);
191 |     if (!promiseKeeper[hash]) {
192 |       promiseKeeper[hash] = Promise.resolve(
193 |         func.apply(funcScope, arguments).then((result: any) => {
194 |           promiseKeeper[hash] = null;
195 |           return result;
196 |         })
197 |       );
198 |     }
199 |     return promiseKeeper[hash];
200 |   };
201 | }
202 | 
203 | function getRequestHash(args: any) {
204 |   const argsJson = JSON.stringify(args);
205 |   return getHash(argsJson);
206 | }
207 | 
208 | function getHash(srt: string) {
209 |   let hash = 0,
210 |     i,
211 |     chr,
212 |     len;
213 |   if (srt.length !== 0) {
214 |     for (i = 0, len = srt.length; i < len; i++) {
215 |       chr = srt.charCodeAt(i);
216 |       hash = (hash << 5) - hash + chr;
217 |       hash |= 0; // Convert to 32bit integer
218 |     }
219 |   }
220 |   return hash;
221 | }
222 | 


--------------------------------------------------------------------------------
/src/types.ts:
--------------------------------------------------------------------------------
  1 | import { DataQuery, DataSourceJsonData, SelectableValue } from '@grafana/data';
  2 | 
  3 | export interface StravaJsonData extends DataSourceJsonData {
  4 |   clientID: string;
  5 |   cacheTTL: string;
  6 |   oauthPassThru: boolean;
  7 | }
  8 | 
  9 | export interface StravaAthlete {
 10 |   profile_medium: string;
 11 |   firstname: string;
 12 |   lastname: string;
 13 |   measurement_preference: StravaMeasurementPreference;
 14 | }
 15 | 
 16 | export interface StravaActivity {
 17 |   id: number;
 18 |   external_id: string;
 19 |   athlete: MetaAthlete;
 20 |   achievement_count: number;
 21 |   average_cadence: number;
 22 |   average_heartrate: number;
 23 |   average_speed: number;
 24 |   upload_id: number;
 25 |   name: string;
 26 |   distance: number;
 27 |   moving_time: number;
 28 |   elapsed_time: number;
 29 |   total_elevation_gain: number;
 30 |   elev_high: number;
 31 |   elev_low: number;
 32 | 
 33 |   /** @deprecated use sport_type */
 34 |   type: ActivityType;
 35 | 
 36 |   sport_type: SportType;
 37 |   start_date: string;
 38 |   start_date_local: string;
 39 |   timezone: string;
 40 |   start_latlng: LatLng;
 41 |   end_latlng: LatLng;
 42 |   kudos_count: number;
 43 |   comment_count: number;
 44 |   athlete_count: number;
 45 |   photo_count: number;
 46 |   total_photo_count: number;
 47 |   map: PolylineMap;
 48 |   trainer: boolean;
 49 |   commute: boolean;
 50 |   manual: boolean;
 51 |   private: boolean;
 52 |   flagged: boolean;
 53 |   from_accepted_tag: boolean;
 54 |   workout_type: number;
 55 |   upload_id_str: string;
 56 |   max_speed: number;
 57 |   has_kudoed: boolean;
 58 |   hide_from_home: boolean;
 59 |   gear_id: string;
 60 |   kilojoules: number;
 61 |   max_heartrate: number;
 62 |   average_watts: number;
 63 |   device_watts: number;
 64 |   max_watts: number;
 65 |   weighted_average_watts: number;
 66 |   display_hide_heartrate_option: boolean;
 67 |   location_city: string | null;
 68 |   location_country: string | null;
 69 |   location_state: string | null;
 70 |   gear: any;
 71 |   splits_metric: any;
 72 |   splits_standard: any;
 73 |   segment_efforts: SegmentEffort[];
 74 | }
 75 | 
 76 | export interface SegmentEffort {
 77 |   id: number;
 78 |   achievements: Achievement[];
 79 |   average_heartrate: number;
 80 |   average_watts: number;
 81 |   distance: number;
 82 |   elapsed_time: number;
 83 |   end_index: number;
 84 |   hidden: boolean;
 85 |   max_heartrate: number;
 86 |   moving_time: number;
 87 |   name: string;
 88 |   pr_rank?: number;
 89 |   start_date: string;
 90 |   start_date_local: string;
 91 |   start_index: number;
 92 |   segment: Segment;
 93 | }
 94 | 
 95 | export interface Segment {
 96 |   id: number;
 97 |   activity_type: ActivityType;
 98 |   athlete_segment_stats: AthleteSegmentStats;
 99 |   average_grade: number;
100 |   city: string;
101 |   climb_category: number;
102 |   country: string;
103 |   distance: number;
104 |   elevation_high: number;
105 |   elevation_low: number;
106 |   start_latlng: LatLng;
107 |   end_latlng: LatLng;
108 |   hazardous: boolean;
109 |   maximum_grade: number;
110 |   name: string;
111 |   private: boolean;
112 |   starred: boolean;
113 |   xoms: XOMs;
114 | }
115 | 
116 | export interface AthleteSegmentStats {
117 |   effort_count: number;
118 |   pr_activity_id: number;
119 |   pr_date: string;
120 |   pr_elapsed_time: number;
121 | }
122 | 
123 | export interface XOMs {
124 |   overall: string;
125 |   kom: string;
126 |   qom: string;
127 |   destination: {
128 |     href: string;
129 |     name: string;
130 |     type: string;
131 |   };
132 | }
133 | 
134 | export interface Achievement {
135 |   rank: number;
136 |   type: string;
137 |   type_id: number;
138 | }
139 | 
140 | export interface DataStream<T> {
141 |   original_size: number;
142 |   resolution: DataStreamResolution;
143 |   series_type: DataStreamSeriesType;
144 |   data: T[];
145 | }
146 | 
147 | export type DataStreamSet<T> = Record<StreamType, DataStream<T>>;
148 | 
149 | export type DataStreamResolution = 'low' | 'medium' | 'high';
150 | 
151 | export type DataStreamSeriesType = 'distance' | 'time';
152 | 
153 | export type ActivityType =
154 |   | 'AlpineSki'
155 |   | 'BackcountrySki'
156 |   | 'Canoeing'
157 |   | 'Crossfit'
158 |   | 'EBikeRide'
159 |   | 'Elliptical'
160 |   | 'Golf'
161 |   | 'Handcycle'
162 |   | 'Hike'
163 |   | 'IceSkate'
164 |   | 'InlineSkate'
165 |   | 'Kayaking'
166 |   | 'Kitesurf'
167 |   | 'NordicSki'
168 |   | 'Ride'
169 |   | 'RockClimbing'
170 |   | 'RollerSki'
171 |   | 'Rowing'
172 |   | 'Run'
173 |   | 'Sail'
174 |   | 'Skateboard'
175 |   | 'Snowboard'
176 |   | 'Snowshoe'
177 |   | 'Soccer'
178 |   | 'StairStepper'
179 |   | 'StandUpPaddling'
180 |   | 'Surfing'
181 |   | 'Swim'
182 |   | 'Velomobile'
183 |   | 'VirtualRide'
184 |   | 'VirtualRun'
185 |   | 'Walk'
186 |   | 'WeightTraining'
187 |   | 'Wheelchair'
188 |   | 'Windsurf'
189 |   | 'Workout'
190 |   | 'Yoga';
191 | 
192 | export type SportType =
193 |   | 'AlpineSki'
194 |   | 'BackcountrySki'
195 |   | 'Badminton'
196 |   | 'Canoeing'
197 |   | 'Crossfit'
198 |   | 'EBikeRide'
199 |   | 'Elliptical'
200 |   | 'EMountainBikeRide'
201 |   | 'Golf'
202 |   | 'GravelRide'
203 |   | 'Handcycle'
204 |   | 'HighIntensityIntervalTraining'
205 |   | 'Hike'
206 |   | 'IceSkate'
207 |   | 'InlineSkate'
208 |   | 'Kayaking'
209 |   | 'Kitesurf'
210 |   | 'MountainBikeRide'
211 |   | 'NordicSki'
212 |   | 'Pickleball'
213 |   | 'Pilates'
214 |   | 'Racquetball'
215 |   | 'Ride'
216 |   | 'RockClimbing'
217 |   | 'RollerSki'
218 |   | 'Rowing'
219 |   | 'Run'
220 |   | 'Sail'
221 |   | 'Skateboard'
222 |   | 'Snowboard'
223 |   | 'Snowshoe'
224 |   | 'Soccer'
225 |   | 'Squash'
226 |   | 'StairStepper'
227 |   | 'StandUpPaddling'
228 |   | 'Surfing'
229 |   | 'Swim'
230 |   | 'TableTennis'
231 |   | 'Tennis'
232 |   | 'TrailRun'
233 |   | 'Velomobile'
234 |   | 'VirtualRide'
235 |   | 'VirtualRow'
236 |   | 'VirtualRun'
237 |   | 'Walk'
238 |   | 'WeightTraining'
239 |   | 'Wheelchair'
240 |   | 'Windsurf'
241 |   | 'Workout'
242 |   | 'Yoga';
243 | 
244 | export function getRunTypes(): Array<Partial<SportType>> {
245 |   return ['Run', 'TrailRun', 'VirtualRun'];
246 | }
247 | 
248 | export function getRideTypes(): Array<Partial<SportType>> {
249 |   return [
250 |     'EBikeRide',
251 |     'EMountainBikeRide',
252 |     'GravelRide',
253 |     'Handcycle',
254 |     'MountainBikeRide',
255 |     'Ride',
256 |     'Velomobile',
257 |     'VirtualRide',
258 |     'Wheelchair',
259 |   ];
260 | }
261 | 
262 | export function getWalkTypes(): Array<Partial<SportType>> {
263 |   return ['Hike', 'Walk'];
264 | }
265 | 
266 | export interface MetaAthlete {
267 |   id: number;
268 |   resource_state: number;
269 | }
270 | 
271 | export type LatLng = [number, number];
272 | 
273 | export interface PolylineMap {
274 |   id: string;
275 |   polyline: string;
276 |   summary_polyline: string;
277 | }
278 | 
279 | export enum StravaMeasurementPreference {
280 |   Meters = 'meters',
281 |   Feet = 'feet',
282 | }
283 | 
284 | export interface StravaSecureJsonData {
285 |   clientSecret: string;
286 | }
287 | 
288 | export interface StravaQuery extends DataQuery {
289 |   queryType: StravaQueryType;
290 |   activityStat: StravaActivityStat;
291 |   activityType: StravaActivityType;
292 |   format: StravaQueryFormat;
293 |   interval: StravaQueryInterval;
294 |   selectedActivity?: SelectableValue<number>;
295 |   activityId?: number;
296 |   activityGraph?: StravaActivityStream;
297 |   activityData?: string;
298 |   splitStat?: StravaSplitStat;
299 |   singleActivityStat?: string;
300 |   fitToTimeRange?: boolean;
301 |   extendedStats: string[];
302 |   segmentEffortId?: number;
303 |   selectedSegmentEffort?: SelectableValue<number>;
304 |   segmentData?: string;
305 |   segmentGraph?: StravaActivityStream;
306 | }
307 | 
308 | export enum StravaQueryFormat {
309 |   TimeSeries = 'time_series',
310 |   Table = 'table',
311 |   WorldMap = 'worldmap',
312 |   Heatmap = 'heatmap',
313 | }
314 | 
315 | export enum StravaQueryInterval {
316 |   No = 'no',
317 |   Auto = 'auto',
318 |   Hour = 'hour',
319 |   Day = 'day',
320 |   Week = 'week',
321 |   Month = 'month',
322 | }
323 | 
324 | export enum StravaQueryType {
325 |   Activities = 'Activities',
326 |   Activity = 'Activity',
327 |   SegmentEffort = 'SegmentEffort',
328 | }
329 | 
330 | export enum StravaActivityStat {
331 |   Distance = 'distance',
332 |   MovingTime = 'moving_time',
333 |   ElapsedTime = 'elapsed_time',
334 |   ElevationGain = 'total_elevation_gain',
335 |   AveragePower = 'average_watts',
336 |   WeightedAveragePower = 'weighted_average_watts',
337 |   AverageHeartRate = 'average_heartrate',
338 | }
339 | 
340 | export type StravaActivityType = string | null;
341 | 
342 | export enum StravaActivityData {
343 |   Graph = 'graph',
344 |   Splits = 'splits',
345 |   Stats = 'stats',
346 |   Geomap = 'geomap',
347 |   Segments = 'segments',
348 | }
349 | 
350 | export enum StravaSplitStat {
351 |   Pace = 'pace',
352 |   HeartRate = 'average_heartrate',
353 |   Speed = 'average_speed',
354 |   MovingTime = 'moving_time',
355 |   ElapsedTime = 'elapsed_time',
356 | }
357 | 
358 | export enum StravaActivityStream {
359 |   Time = 'time',
360 |   Distance = 'distance',
361 |   HeartRate = 'heartrate',
362 |   Altitude = 'altitude',
363 |   Cadence = 'cadence',
364 |   Velocity = 'velocity_smooth',
365 |   // Special type for pace which actually calculated from velocity
366 |   Pace = 'pace',
367 |   Watts = 'watts',
368 |   WattsCalc = 'watts_calc',
369 |   Temp = 'temp',
370 |   Moving = 'moving',
371 |   GradeSmooth = 'grade_smooth',
372 |   GradeAdjustedDistance = 'grade_adjusted_distance',
373 |   LatLng = 'latlng',
374 | }
375 | 
376 | export type StreamType =
377 |   | 'heartrate'
378 |   | 'altitude'
379 |   | 'distance'
380 |   | 'cadence'
381 |   | 'velocity_smooth'
382 |   | 'latlng'
383 |   | 'watts'
384 |   | 'watts_calc'
385 |   | 'temp'
386 |   | 'moving'
387 |   | 'grade_smooth'
388 |   | 'grade_adjusted_distance'
389 |   | 'time'
390 |   | 'timer_time';
391 | 
392 | export interface VariableQuery {
393 |   queryType: VariableQueryTypes;
394 |   activityType: string;
395 |   limit: number;
396 |   activityId: string;
397 | }
398 | 
399 | export enum VariableQueryTypes {
400 |   Activity = 'activity',
401 |   SegmentEffort = 'segment_effort',
402 | }
403 | 
404 | export const TopAchievementStat = 'top_achievement';
405 | 
406 | export const GRAPH_SMOOTH_WINDOW = 20;
407 | 


--------------------------------------------------------------------------------
/src/utils.ts:
--------------------------------------------------------------------------------
  1 | import { DisplayValue, TimeRange } from '@grafana/data';
  2 | import { DataStream, GRAPH_SMOOTH_WINDOW, StravaMeasurementPreference, StravaQuery, StravaQueryInterval } from 'types';
  3 | 
  4 | export const INTERVAL_1h = 3600000;
  5 | export const INTERVAL_1d = 86400000;
  6 | export const INTERVAL_1w = 604800000;
  7 | export const INTERVAL_4w = 2419200000;
  8 | 
  9 | export function getAggregationInterval(range: TimeRange): number {
 10 |   const interval = range.to.unix() - range.from.unix();
 11 |   const interval_ms = interval * 1000;
 12 |   switch (true) {
 13 |     // 4d
 14 |     case interval_ms <= 345600000:
 15 |       return INTERVAL_1h; // 1h
 16 |     // 90d
 17 |     case interval_ms <= 7776000000:
 18 |       return INTERVAL_1d; // 1d
 19 |     // 1y
 20 |     case interval_ms <= 31536000000:
 21 |       return INTERVAL_1w; // 1w
 22 |     default:
 23 |       return INTERVAL_4w; // 4w
 24 |   }
 25 | }
 26 | 
 27 | export function getAggregationIntervalFromTarget(target: StravaQuery): number {
 28 |   switch (target.interval) {
 29 |     case StravaQueryInterval.Hour:
 30 |       return INTERVAL_1h;
 31 |     case StravaQueryInterval.Day:
 32 |       return INTERVAL_1d;
 33 |     case StravaQueryInterval.Week:
 34 |       return INTERVAL_1w;
 35 |     case StravaQueryInterval.Month:
 36 |       return INTERVAL_4w;
 37 |     default:
 38 |       return INTERVAL_4w;
 39 |   }
 40 | }
 41 | 
 42 | export function getPreferredDistance(value: number, measurementPreference: StravaMeasurementPreference): number {
 43 |   return measurementPreference === StravaMeasurementPreference.Feet ? metersToMiles(value) : value;
 44 | }
 45 | 
 46 | export function getPreferredLength(value: number, measurementPreference: StravaMeasurementPreference): number {
 47 |   return measurementPreference === StravaMeasurementPreference.Feet ? metersToFeet(value) : value;
 48 | }
 49 | 
 50 | export function getPreferredSpeed(value: number, measurementPreference: StravaMeasurementPreference): number {
 51 |   const speedKmph = velocityToSpeed(value);
 52 |   return measurementPreference === StravaMeasurementPreference.Feet ? metersToMiles(speedKmph * 1000) : speedKmph;
 53 | }
 54 | 
 55 | export function getPreferredSpeedUnit(measurementPreference: StravaMeasurementPreference) {
 56 |   return measurementPreference === StravaMeasurementPreference.Feet ? 'velocitymph' : 'velocitykmh';
 57 | }
 58 | 
 59 | export function getPreferredLengthUnit(measurementPreference: StravaMeasurementPreference) {
 60 |   return measurementPreference === StravaMeasurementPreference.Feet ? 'lengthft' : 'lengthm';
 61 | }
 62 | 
 63 | export function getPreferredPace(value: number, measurementPreference: StravaMeasurementPreference): number {
 64 |   const paceMinkm = velocityToPace(value);
 65 |   return measurementPreference === StravaMeasurementPreference.Feet ? paceToMiles(paceMinkm) : paceMinkm;
 66 | }
 67 | 
 68 | export function metersToFeet(value: number): number {
 69 |   return value / 0.3048;
 70 | }
 71 | 
 72 | export function metersToMiles(value: number): number {
 73 |   return value / 1609.344;
 74 | }
 75 | 
 76 | export function paceToMiles(value: number): number {
 77 |   return (value * 1609.344) / 1000;
 78 | }
 79 | 
 80 | export function velocityToPace(mps: number): number {
 81 |   if (mps === 0) {
 82 |     return 0;
 83 |   }
 84 |   const pace = Math.fround(1000 / mps);
 85 |   // Limit pace to 10 min/km to avoid spikes on graph (pace is a reversed speed)
 86 |   return Math.min(10 * 60, pace);
 87 | }
 88 | 
 89 | export function velocityToSpeed(mps: number): number {
 90 |   // m/s to km/h
 91 |   return mps * 3.6;
 92 | }
 93 | 
 94 | export function velocityDataToPace(data: Array<number | null>, mp: StravaMeasurementPreference): Array<number | null> {
 95 |   for (let i = 0; i < data.length; i++) {
 96 |     // m/s to min/km
 97 |     const point = data[i];
 98 |     if (point != null) {
 99 |       const paceMinkm = velocityToPace(point);
100 |       data[i] = mp === StravaMeasurementPreference.Feet ? paceToMiles(paceMinkm) : paceMinkm;
101 |     }
102 |   }
103 |   return data;
104 | }
105 | 
106 | export function velocityDataToSpeed(data: Array<number | null>, mp: StravaMeasurementPreference): Array<number | null> {
107 |   for (let i = 0; i < data.length; i++) {
108 |     // m/s to km/h
109 |     const point = data[i];
110 |     if (point != null) {
111 |       const speedKmph = velocityToSpeed(point);
112 |       data[i] = mp === StravaMeasurementPreference.Feet ? metersToMiles(speedKmph * 1000) : speedKmph;
113 |     }
114 |   }
115 |   return data;
116 | }
117 | 
118 | export function metersDataToFeet(data: Array<number | null>, mp: StravaMeasurementPreference): Array<number | null> {
119 |   for (let i = 0; i < data.length; i++) {
120 |     const point = data[i];
121 |     if (point != null) {
122 |       data[i] = mp === StravaMeasurementPreference.Feet ? metersToFeet(point) : point;
123 |     }
124 |   }
125 |   return data;
126 | }
127 | 
128 | export function smoothVelocityData(data: Array<number | null>): Array<number | null> {
129 |   // It's not possible to calculate MA if n greater than number of points
130 |   const n = Math.min(GRAPH_SMOOTH_WINDOW, data.length);
131 | 
132 |   const sma = [];
133 |   let w_sum = 0;
134 |   let w_count = 0;
135 |   let point: number | null = null;
136 | 
137 |   // Initial window
138 |   for (let i = n; i > 0; i--) {
139 |     point = data[n - i];
140 |     if (point != null) {
141 |       w_sum += point;
142 |       w_count++;
143 |     }
144 |   }
145 |   for (let i = 0; i < n; i++) {
146 |     sma.push(w_sum / w_count);
147 |   }
148 | 
149 |   for (let i = n; i < data.length; i++) {
150 |     w_sum = 0;
151 |     w_count = 0;
152 |     for (let j = 0; j < n; j++) {
153 |       point = data[i - j];
154 |       if (point != null) {
155 |         w_sum += point;
156 |         w_count++;
157 |       }
158 |     }
159 |     sma.push(w_sum / w_count);
160 |   }
161 |   return sma;
162 | }
163 | 
164 | export const paceDisplayProcessor = (value: any): DisplayValue => {
165 |   let text = '';
166 |   const displayValue: DisplayValue = {
167 |     numeric: value,
168 |     text,
169 |   };
170 | 
171 |   if (value) {
172 |     const minutes = Math.floor(value / 60);
173 |     const seconds = Math.round(value - minutes * 60);
174 |     text = `${minutes}:${seconds}`;
175 |     displayValue.text = text;
176 |     displayValue.suffix = ' /km';
177 |   }
178 |   return displayValue;
179 | };
180 | 
181 | // Expands stream data to normal array with nulls for non-existing points.
182 | // Data comes as a kind of sparse array. Time stream contains offset of data
183 | // points, for example:
184 | // heartrate: [70,81,82,81,99,96,97,98,99]
185 | // time:      [0, 4, 5, 6, 20,21,22,23,24]
186 | // So last value of the time stream is a highest index in data array
187 | export function expandDataStream<T>(
188 |   dataStream: DataStream<T>,
189 |   timeStream: DataStream<number>,
190 |   startTS: number,
191 |   startIndex: number,
192 |   endIndex: number
193 | ): [Array<T | null>, number[]] {
194 |   const streamLength: number = timeStream.data[endIndex] - timeStream.data[startIndex];
195 |   const streamValues = new Array<T | null>(streamLength).fill(null);
196 |   const segmentTicks = new Array<number>(0);
197 | 
198 |   const firstTsIndex = timeStream.data[startIndex];
199 |   let ts = startTS + firstTsIndex;
200 |   for (let i = startIndex; i < startIndex + streamLength; i++) {
201 |     segmentTicks.push(ts * 1000);
202 |     ts++;
203 |   }
204 |   for (let i = startIndex; i < endIndex; i++) {
205 |     streamValues[timeStream.data[i] - firstTsIndex] = dataStream.data[i];
206 |   }
207 | 
208 |   return [streamValues, segmentTicks];
209 | }
210 | 


--------------------------------------------------------------------------------
/tsconfig.jest.json:
--------------------------------------------------------------------------------
1 | {
2 |   "extends": "./tsconfig"
3 | }
4 | 


--------------------------------------------------------------------------------
/tsconfig.json:
--------------------------------------------------------------------------------
1 | {
2 |   "extends": "./.config/tsconfig.json"
3 | }


--------------------------------------------------------------------------------