├── .gitignore
├── LICENSE
├── README.md
├── images
    └── red-subscribe-publish.gif
├── nodes
    ├── api
    │   ├── api.html
    │   ├── api.js
    │   └── icons
    │   │   ├── particle.png
    │   │   └── particle@2x.png
    ├── config
    │   ├── config.html
    │   ├── config.js
    │   └── helpers.js
    ├── function
    │   ├── function.html
    │   ├── function.js
    │   └── icons
    │   │   ├── particle.png
    │   │   └── particle@2x.png
    ├── publish
    │   ├── icons
    │   │   ├── particle.png
    │   │   └── particle@2x.png
    │   ├── publish.html
    │   └── publish.js
    ├── subscribe
    │   ├── icons
    │   │   ├── particle.png
    │   │   └── particle@2x.png
    │   ├── subscribe.html
    │   └── subscribe.js
    └── variable
    │   ├── icons
    │       ├── particle.png
    │       └── particle@2x.png
    │   ├── variable.html
    │   └── variable.js
├── package-lock.json
├── package.json
└── src
    ├── api.js
    ├── helpers.js
    └── particle-base-node.js


/.gitignore:
--------------------------------------------------------------------------------
1 | node_modules
2 | npm-debug.log
3 | .DS_Store
4 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2020 Particle Industries
 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 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # Node-RED Particle nodes
 2 | 
 3 | ![](images/red-subscribe-publish.gif)
 4 | 
 5 | ## Installation
 6 | 
 7 | ```bash
 8 | $ cd ~/.node-red
 9 | $ npm install @particle/node-red-contrib-particle-official
10 | ```
11 | 
12 | ## Version History
13 | 
14 | #### 0.1.7 (2021-05-13)
15 | 
16 | - Upgrade lodash from 4.17.19 to 4.17.21 for security vulnerability fix
17 | 
18 | #### 0.1.6 (2020-11-30)
19 | 
20 | - Fixed a bug where a subscribe node would keep using the same value it received on the first event, even if the value changed.
21 |     "lodash": "^4.17.19",
22 |     "lodash": "^4.17.21",


--------------------------------------------------------------------------------
/images/red-subscribe-publish.gif:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/particle-iot/node-red-contrib-particle-official/62bd7258e41946e979722db8907deb7ca148dd23/images/red-subscribe-publish.gif


--------------------------------------------------------------------------------
/nodes/api/api.html:
--------------------------------------------------------------------------------
  1 | 
  2 | <script>
  3 | 
  4 | // BEGIN helpers.js - This code is automatically updated, do not manually edit!
  5 | if (typeof window !== 'undefined' && !window.helpers) {
  6 | 
  7 | 	const generateFieldScopeSelector = () => {
  8 | 		return `
  9 | 			<div class="form-row form-row-radio">
 10 | 					<label for="node-input-scope"><i class="im im-scope-icon"></i> <span>Scope</span></label>
 11 | 					<label class="radio">
 12 | 					<input type="radio" name="node-input-scope-options" id="node-input-scope-user" value="user">
 13 | 					User
 14 | 					</label>
 15 | 					<label class="radio">
 16 | 					<input type="radio" name="node-input-scope-options" id="node-input-scope-product" value="product">
 17 | 					Product
 18 | 					</label>
 19 | 					<input type="hidden" id="node-input-scope">
 20 | 			</div>
 21 | 			<div class="form-row hidden" id="particle-scope-product">
 22 | 					<label for="node-input-scope"><i class="im im-product-icon"></i> <span>Product</span></label>
 23 | 					<input type="text" id="node-input-product" placeholder="Product slug or ID">
 24 | 			</div>
 25 | 		`;
 26 | 	};
 27 | 
 28 | 	const generateFieldSelect = (field) => {
 29 | 		let html = `
 30 | 			<div class="form-row">
 31 | 					<label for="node-input-${field.name}"><i class="${field.icon}"></i> ${field.title}</label>
 32 | 
 33 | 					<select id="node-input-${field.name}">
 34 | 		`;
 35 | 
 36 | 		field.values.forEach(val => {
 37 | 			if (val.value === field.defaultValue) {
 38 | 				html += `<option value="${val.value}" selected>${val.title}</option>`;
 39 | 			} else {
 40 | 				html += `<option value="${val.value}">${val.title}</option>`;
 41 | 			}
 42 | 		});
 43 | 
 44 | 		html += `
 45 | 				</select>
 46 | 			</div>
 47 | 		`;
 48 | 
 49 | 		return html;
 50 | 	};
 51 | 
 52 | 	const generateField = (field) => {
 53 | 		let html = '';
 54 | 
 55 | 		if (field.type === 'scope-selector') {
 56 | 			html = generateFieldScopeSelector(field);
 57 | 		} else if (field.type === 'select') {
 58 | 			html = generateFieldSelect(field);
 59 | 		} else {
 60 | 			html = `
 61 | 				<div class="form-row">
 62 | 						<label for="node-input-${field.name}"><i class="${field.icon}"></i> ${field.title}</label>
 63 | 						<input type="${field.type === 'object' ? 'text' : field.type}" id="node-input-${field.name}" placeholder="${field.placeholder}">
 64 | 				</div>
 65 | 			`;
 66 | 		}
 67 | 
 68 | 		return html;
 69 | 	};
 70 | 
 71 | 	const generateEditTemplate = ({ name, fields }) => {
 72 | 		let html = '';
 73 | 
 74 | 		fields.forEach(field => {
 75 | 			html += generateField(field);
 76 | 		});
 77 | 
 78 | 		$(`script[data-template-name="${name}"]`).html(html);
 79 | 	};
 80 | 
 81 | 	const generateDocumentation = ({ name, title, inputs, outputs, details, resources }) => {
 82 | 		let html = `
 83 | 					<p>${title}</p>
 84 | 			`;
 85 | 
 86 | 		if (inputs) {
 87 | 			html += `
 88 | 				<h3>Inputs</h3>
 89 | 				<dl class="message-properties">
 90 | 			`;
 91 | 
 92 | 			inputs.forEach(input => {
 93 | 				html += `
 94 | 								<dt class="${input.optional ? 'optional' : ''}">${input.name} <span class="property-type">${input.type}</span></dt>
 95 | 								<dd>${input.description}</dd>
 96 | 						`;
 97 | 			});
 98 | 		}
 99 | 
100 | 		html += `
101 | 					</dl>
102 | 		`;
103 | 
104 | 		if (outputs) {
105 | 			html += `
106 | 						<h3>Outputs</h3>
107 | 						<dl class="message-properties">
108 | 			`;
109 | 
110 | 			outputs.forEach(output => {
111 | 				html += `
112 | 								<dt>${output.name} <span class="property-type">${output.type}</span></dt>
113 | 								<dd>${output.description}</dd>
114 | 						`;
115 | 			});
116 | 
117 | 
118 | 			html += `
119 | 						</dl>
120 | 			`;
121 | 		}
122 | 
123 | 		html += `
124 | 					</dl>
125 | 					<h3>Details</h3>
126 | 					<p>${details}</p>
127 | 					<h3>Resources</h3>
128 | 					<ul>
129 | 		`;
130 | 
131 | 
132 | 
133 | 		resources.forEach(resource => {
134 | 			html += `
135 | 							<li>
136 | 									<a href="${resource.link}">${resource.name}</a> - ${resource.description}
137 | 							</li>
138 | 					`;
139 | 		});
140 | 
141 | 		html += '</ul>';
142 | 
143 | 		$(`script[data-help-name="${name}"]`).html(html);
144 | 	};
145 | 
146 | 	const generateClientConfig = (config) => {
147 | 		let nodeClient = Object.assign({}, config, {
148 | 			category: 'particle',
149 | 			color: '#C0DEED'
150 | 		});
151 | 
152 | 		if (config._scopeSelector === true) {
153 | 			nodeClient.onScopeChange = function onscopechange() {
154 | 				let stream = $('input[name=node-input-scope-options]:checked').val() || 'user';
155 | 
156 | 				if (stream === 'product') {
157 | 					$('#particle-scope-product').removeClass('hidden');
158 | 				} else {
159 | 					$('#particle-scope-product').addClass('hidden');
160 | 					$('#node-input-product').val('');
161 | 				}
162 | 
163 | 				$('#node-input-stream').val(stream);
164 | 			};
165 | 
166 | 			nodeClient.oneditprepare = function oneditprepare() {
167 | 				$('input[name=node-input-scope-options]')
168 | 					.prop('checked', null)
169 | 					.change(nodeClient.onScopeChange.bind(this));
170 | 
171 | 				const isProduct = $('#node-input-product').val();
172 | 
173 | 				if (isProduct) {
174 | 					$('#node-input-scope-product').prop('checked', true);
175 | 				} else {
176 | 					$('#node-input-scope-user').prop('checked', true);
177 | 				}
178 | 
179 | 				nodeClient.onScopeChange();
180 | 			};
181 | 
182 | 			nodeClient.oneditsave = function oneditsave() {
183 | 				nodeClient.onScopeChange();
184 | 			};
185 | 		}
186 | 
187 | 		return nodeClient;
188 | 	};
189 | 
190 | 	const addCSS = () => {
191 | 		$('body').append(`
192 | 			<link rel="stylesheet" href="https://s3.amazonaws.com/icomoon.io/49057/Dashboard/style.css?r41hg3">
193 | 			<style>
194 | 					.form-row input[type="radio"] {
195 | 							width: auto !important;
196 | 					}
197 | 
198 | 					.form-row label i.fa {
199 | 							width: 14px;
200 | 					}
201 | 
202 | 					.form-row-radio {
203 | 							padding-top: 9px;
204 | 					}
205 | 			</style>
206 | 		`);
207 | 	};
208 | 
209 | 	const generateNodeFromDefinition = (name, definition) => {
210 | 		generateEditTemplate(definition.editTemplate);
211 | 		generateDocumentation(definition.documentation);
212 | 		addCSS();
213 | 
214 | 		RED.nodes.registerType(name, generateClientConfig(definition.client));
215 | 	};
216 | 
217 | 	/*global window*/
218 | 	window.helpers = {
219 | 		generateEditTemplate,
220 | 		generateDocumentation,
221 | 		generateClientConfig,
222 | 		generateNodeFromDefinition
223 | 	};
224 | 
225 | }    
226 | // END helpers.js - This code is automatically updated, do not manually edit!
227 | 
228 | 
229 | /* eslint-disable indent */
230 | const apiEditTemplate = {
231 | 	name: 'particle-api',
232 | 	fields: [
233 | 		{ name: 'name', icon: 'icon-tag', title: 'Name', placeholder: 'Name', type: 'text' },
234 | 		{ name: 'auth', icon: 'fa fa-user', title: 'Auth', placeholder: 'Auth', type: 'text' },
235 | 		{ name: 'method', icon: 'fa fa-tasks', title: 'Method', type: 'select',
236 | 				values: [
237 | 					{ title: 'GET', value: 'get' },
238 | 					{ title: 'HEAD', value: 'head' },
239 | 					{ title: 'POST', value: 'post' },
240 | 					{ title: 'PUT', value: 'put' },
241 | 					{ title: 'DELETE', value: 'DELETE' }
242 | 				],
243 | 				defaultValue: 'get'
244 | 		},
245 | 		{ name: 'url', icon: 'fa fa-globe', title: 'URL', placeholder: 'https://api.particle.io/[url]', type: 'text' }
246 | 	]
247 | };
248 | /* eslint-enable indent */
249 | const apiDocumentation = {
250 | 	name: 'particle-api',
251 | 	title: 'Sends HTTP requests to the Particle API and returns the response.',
252 | 	inputs: [
253 | 		{ name: 'url', type: 'string', description: 'If not configured in node properties, this optional property sets the part of the URL <b>after the Particle API base path</b> <code>https://api.particle.io/</code> for the request', optional: true },
254 | 		{ name: 'method', type: 'string', description: 'If not configured in node properties, this optional property sets the HTTP method of the request. Must be one of <code>GET</code>, <code>HEAD</code>, <code>POST</code>, <code>PUT</code>, or <code>DELETE</code>', optional: true },
255 | 		{ name: 'payload', type: 'object', description: 'The JSON payload that will be sent as the body of the request', optional: true }
256 | 	],
257 | 	outputs: [
258 | 		{ name: 'payload', type: 'string', description: 'The JSON body returned from the Particle API' },
259 | 		{ name: 'statusCode', type: 'string', description: 'The HTTP status code returned from the Particle API' }
260 | 	],
261 | 	details: `
262 | 		<p>The Particle API allows you to interact remotely with the Device Cloud via a RESTful interface.</p>
263 | 		<p>This node is intended to be placed in the middle of a flow to make an HTTP request to the Particle API.</p>
264 | 		<p>You may set the URL and HTTP method of the request either as part of node properties, or by passing <code>msg.url</code> or <code>msg.method</code> as an input to this node, respectively.</p>
265 | 		<p>Note that <code>url</code> will be automatically prefixed with the Particle API base path, <code>https://api.particle.io</code>. Your url should begin with the API version (<code>v1/</code>) and continue based on the endpoint you are targeting.</p>
266 | 		<p>If you would like to send a JSON payload as the body of the request, pass <code>msg.payload</code> as an input to this node.</p>
267 | 	`,
268 | 	resources: [
269 | 		{ name: 'API reference docs', link: 'https://docs.particle.io/reference/api/', description: 'Learn more about the available REST endpoints of the Particle API' }
270 | 	]
271 | };
272 | 
273 | const apiClient = {
274 | 	defaults: {
275 | 		name: { value: '' },
276 | 		auth: { type: 'particle-config', required: true },
277 | 		method: { value: 'get' },
278 | 		url: {},
279 | 		payload: {}
280 | 	},
281 | 	inputs: 1,
282 | 	outputs: 1,
283 | 	icon: 'particle.png',
284 | 	align: 'left',
285 | 	paletteLabel: function() {
286 | 		return 'particle api';
287 | 	},
288 | 	label: function label() {
289 | 		if (this.name) {
290 | 			return this.name;
291 | 		}
292 | 
293 | 		if (this.method && this.url) {
294 | 			return `${this.method.toUpperCase()} ${this.url}`;
295 | 		} else if (this.url) {
296 | 			return `api ${this.url}`;
297 | 		}
298 | 
299 | 		return apiClient.paletteLabel();
300 | 	}
301 | };
302 | 
303 | /*global window*/
304 | window.APINodeDefinition = {
305 | 	editTemplate:apiEditTemplate,
306 | 	documentation:apiDocumentation,
307 | 	client:apiClient
308 | };
309 | 
310 | window.helpers.generateNodeFromDefinition('particle-api', window.APINodeDefinition);
311 | </script>
312 | 
313 | <script type="text/x-red" data-template-name="particle-api"></script>
314 | <script type="text/x-red" data-help-name="particle-api"></script>


--------------------------------------------------------------------------------
/nodes/api/api.js:
--------------------------------------------------------------------------------
 1 | 'use strict';
 2 | 
 3 | const ParticleBaseNode = require('../../src/particle-base-node');
 4 | 
 5 | module.exports = (RED) => {
 6 | 	function ParticleAPINode(node) {
 7 | 		RED.nodes.createNode(this, node);
 8 | 
 9 | 		new ParticleBaseNode({
10 | 			self: this,
11 | 			node: node,
12 | 			RED: RED,
13 | 			properties: ['name', 'method', 'url', 'payload'],
14 | 			inputProperties: ['method', 'url', 'payload'],
15 | 			functionName: 'request',
16 | 			functionArguments: [
17 | 				{ key: 'uri', value: 'url', prefix: 'https://api.particle.io/', customValue: ({ url }) => {
18 | 					if (url[0] === '/') {
19 | 						url = url.substring(1);
20 | 					}
21 | 
22 | 					return url;
23 | 				} },
24 | 				{ key: 'method', value: 'method' },
25 | 				{ key: 'data', value: 'payload', format: 'object' }
26 | 			],
27 | 			mandatoryArguments: ['uri', 'method'],
28 | 			success: {
29 | 				fields: [
30 | 					{ key: 'payload', path: 'body' },
31 | 					{ key: 'statusCode', path: 'statusCode' }
32 | 				],
33 | 				status: 'got response'
34 | 			},
35 | 			info: {
36 | 				status: 'requesting'
37 | 			},
38 | 			error: {
39 | 				status: 'failed',
40 | 				onRuntime: 'Failed to call endpoint',
41 | 				onConfig: 'Configuration error'
42 | 			}
43 | 		});
44 | 	}
45 | 
46 | 	RED.nodes.registerType('particle-api', ParticleAPINode);
47 | 
48 | };
49 | 


--------------------------------------------------------------------------------
/nodes/api/icons/particle.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/particle-iot/node-red-contrib-particle-official/62bd7258e41946e979722db8907deb7ca148dd23/nodes/api/icons/particle.png


--------------------------------------------------------------------------------
/nodes/api/icons/particle@2x.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/particle-iot/node-red-contrib-particle-official/62bd7258e41946e979722db8907deb7ca148dd23/nodes/api/icons/particle@2x.png


--------------------------------------------------------------------------------
/nodes/config/config.html:
--------------------------------------------------------------------------------
 1 | <script type="text/javascript">
 2 |     RED.nodes.registerType('particle-config', {
 3 | 		category: 'config',
 4 | 		defaults: {
 5 | 			clientId: { required: true },
 6 | 			clientSecret: { required: true }
 7 | 		},
 8 | 		label: function() {
 9 | 			return this.clientId;
10 | 		}
11 |     });
12 | </script>
13 | 
14 | <script type="text/x-red" data-template-name="particle-config">
15 |     <h5>1. Create a Particle OAuth client</h5>
16 |     <p>Follow the instructions from the <a href="https://docs.particle.io/guide/how-to-build-a-product/authentication/#creating-an-oauth-client">authentication guide</a>.</p>
17 | 
18 |     <div class="info">
19 |         Make sure that you choose "Two-Legged Auth (Server)" as the client type to ensure sufficient permissions.
20 |     </div>
21 | 
22 |     <h5>2. Copy the OAuth client credentials here:</h5>
23 |     <div class="form-row">
24 |         <label for="node-config-input-clientId"><i class="fa fa-id-badge"></i> Client ID</label>
25 |         <input type="text" id="node-config-input-clientId">
26 |     </div>
27 |     <div class="form-row">
28 |         <label for="node-config-input-clientSecret"><i class="fa fa-user-secret"></i> Client Secret</label>
29 |         <input type="password" id="node-config-input-clientSecret">
30 |     </div>
31 | </script>
32 | 


--------------------------------------------------------------------------------
/nodes/config/config.js:
--------------------------------------------------------------------------------
 1 | 'use strict';
 2 | 
 3 | module.exports = (RED) => {
 4 | 	function ParticleConfigNode(n) {
 5 | 		RED.nodes.createNode(this, n);
 6 | 		this.clientId = n.clientId;
 7 | 		this.clientSecret = n.clientSecret;
 8 | 	}
 9 | 
10 | 	RED.nodes.registerType('particle-config', ParticleConfigNode);
11 | 
12 | };
13 | 


--------------------------------------------------------------------------------
/nodes/config/helpers.js:
--------------------------------------------------------------------------------
  1 | 'use strict';
  2 | 
  3 | if (typeof window !== 'undefined' && !window.helpers) {
  4 | 
  5 | 	const generateFieldScopeSelector = () => {
  6 | 		return `
  7 | 			<div class="form-row form-row-radio">
  8 | 					<label for="node-input-scope"><i class="im im-scope-icon"></i> <span>Scope</span></label>
  9 | 					<label class="radio">
 10 | 					<input type="radio" name="node-input-scope-options" id="node-input-scope-user" value="user">
 11 | 					User
 12 | 					</label>
 13 | 					<label class="radio">
 14 | 					<input type="radio" name="node-input-scope-options" id="node-input-scope-product" value="product">
 15 | 					Product
 16 | 					</label>
 17 | 					<input type="hidden" id="node-input-scope">
 18 | 			</div>
 19 | 			<div class="form-row hidden" id="particle-scope-product">
 20 | 					<label for="node-input-scope"><i class="im im-product-icon"></i> <span>Product</span></label>
 21 | 					<input type="text" id="node-input-product" placeholder="Product slug or ID">
 22 | 			</div>
 23 | 		`;
 24 | 	};
 25 | 
 26 | 	const generateFieldSelect = (field) => {
 27 | 		let html = `
 28 | 			<div class="form-row">
 29 | 					<label for="node-input-${field.name}"><i class="${field.icon}"></i> ${field.title}</label>
 30 | 
 31 | 					<select id="node-input-${field.name}">
 32 | 		`;
 33 | 
 34 | 		field.values.forEach(val => {
 35 | 			if (val.value === field.defaultValue) {
 36 | 				html += `<option value="${val.value}" selected>${val.title}</option>`;
 37 | 			} else {
 38 | 				html += `<option value="${val.value}">${val.title}</option>`;
 39 | 			}
 40 | 		});
 41 | 
 42 | 		html += `
 43 | 				</select>
 44 | 			</div>
 45 | 		`;
 46 | 
 47 | 		return html;
 48 | 	};
 49 | 
 50 | 	const generateField = (field) => {
 51 | 		let html = '';
 52 | 
 53 | 		if (field.type === 'scope-selector') {
 54 | 			html = generateFieldScopeSelector(field);
 55 | 		} else if (field.type === 'select') {
 56 | 			html = generateFieldSelect(field);
 57 | 		} else {
 58 | 			html = `
 59 | 				<div class="form-row">
 60 | 						<label for="node-input-${field.name}"><i class="${field.icon}"></i> ${field.title}</label>
 61 | 						<input type="${field.type === 'object' ? 'text' : field.type}" id="node-input-${field.name}" placeholder="${field.placeholder}">
 62 | 				</div>
 63 | 			`;
 64 | 		}
 65 | 
 66 | 		return html;
 67 | 	};
 68 | 
 69 | 	const generateEditTemplate = ({ name, fields }) => {
 70 | 		let html = '';
 71 | 
 72 | 		fields.forEach(field => {
 73 | 			html += generateField(field);
 74 | 		});
 75 | 
 76 | 		$(`script[data-template-name="${name}"]`).html(html);
 77 | 	};
 78 | 
 79 | 	const generateDocumentation = ({ name, title, inputs, outputs, details, resources }) => {
 80 | 		let html = `
 81 | 					<p>${title}</p>
 82 | 			`;
 83 | 
 84 | 		if (inputs) {
 85 | 			html += `
 86 | 				<h3>Inputs</h3>
 87 | 				<dl class="message-properties">
 88 | 			`;
 89 | 
 90 | 			inputs.forEach(input => {
 91 | 				html += `
 92 | 								<dt class="${input.optional ? 'optional' : ''}">${input.name} <span class="property-type">${input.type}</span></dt>
 93 | 								<dd>${input.description}</dd>
 94 | 						`;
 95 | 			});
 96 | 		}
 97 | 
 98 | 		html += `
 99 | 					</dl>
100 | 		`;
101 | 
102 | 		if (outputs) {
103 | 			html += `
104 | 						<h3>Outputs</h3>
105 | 						<dl class="message-properties">
106 | 			`;
107 | 
108 | 			outputs.forEach(output => {
109 | 				html += `
110 | 								<dt>${output.name} <span class="property-type">${output.type}</span></dt>
111 | 								<dd>${output.description}</dd>
112 | 						`;
113 | 			});
114 | 
115 | 
116 | 			html += `
117 | 						</dl>
118 | 			`;
119 | 		}
120 | 
121 | 		html += `
122 | 					</dl>
123 | 					<h3>Details</h3>
124 | 					<p>${details}</p>
125 | 					<h3>Resources</h3>
126 | 					<ul>
127 | 		`;
128 | 
129 | 
130 | 
131 | 		resources.forEach(resource => {
132 | 			html += `
133 | 							<li>
134 | 									<a href="${resource.link}">${resource.name}</a> - ${resource.description}
135 | 							</li>
136 | 					`;
137 | 		});
138 | 
139 | 		html += '</ul>';
140 | 
141 | 		$(`script[data-help-name="${name}"]`).html(html);
142 | 	};
143 | 
144 | 	const generateClientConfig = (config) => {
145 | 		let nodeClient = Object.assign({}, config, {
146 | 			category: 'particle',
147 | 			color: '#C0DEED'
148 | 		});
149 | 
150 | 		if (config._scopeSelector === true) {
151 | 			nodeClient.onScopeChange = function onscopechange() {
152 | 				let stream = $('input[name=node-input-scope-options]:checked').val() || 'user';
153 | 
154 | 				if (stream === 'product') {
155 | 					$('#particle-scope-product').removeClass('hidden');
156 | 				} else {
157 | 					$('#particle-scope-product').addClass('hidden');
158 | 					$('#node-input-product').val('');
159 | 				}
160 | 
161 | 				$('#node-input-stream').val(stream);
162 | 			};
163 | 
164 | 			nodeClient.oneditprepare = function oneditprepare() {
165 | 				$('input[name=node-input-scope-options]')
166 | 					.prop('checked', null)
167 | 					.change(nodeClient.onScopeChange.bind(this));
168 | 
169 | 				const isProduct = $('#node-input-product').val();
170 | 
171 | 				if (isProduct) {
172 | 					$('#node-input-scope-product').prop('checked', true);
173 | 				} else {
174 | 					$('#node-input-scope-user').prop('checked', true);
175 | 				}
176 | 
177 | 				nodeClient.onScopeChange();
178 | 			};
179 | 
180 | 			nodeClient.oneditsave = function oneditsave() {
181 | 				nodeClient.onScopeChange();
182 | 			};
183 | 		}
184 | 
185 | 		return nodeClient;
186 | 	};
187 | 
188 | 	const addCSS = () => {
189 | 		$('body').append(`
190 | 			<link rel="stylesheet" href="https://s3.amazonaws.com/icomoon.io/49057/Dashboard/style.css?r41hg3">
191 | 			<style>
192 | 					.form-row input[type="radio"] {
193 | 							width: auto !important;
194 | 					}
195 | 
196 | 					.form-row label i.fa {
197 | 							width: 14px;
198 | 					}
199 | 
200 | 					.form-row-radio {
201 | 							padding-top: 9px;
202 | 					}
203 | 			</style>
204 | 		`);
205 | 	};
206 | 
207 | 	const generateNodeFromDefinition = (name, definition) => {
208 | 		generateEditTemplate(definition.editTemplate);
209 | 		generateDocumentation(definition.documentation);
210 | 		addCSS();
211 | 
212 | 		RED.nodes.registerType(name, generateClientConfig(definition.client));
213 | 	};
214 | 
215 | 	/*global window*/
216 | 	window.helpers = {
217 | 		generateEditTemplate,
218 | 		generateDocumentation,
219 | 		generateClientConfig,
220 | 		generateNodeFromDefinition
221 | 	};
222 | 
223 | }


--------------------------------------------------------------------------------
/nodes/function/function.html:
--------------------------------------------------------------------------------
  1 | 
  2 | <script>
  3 | // BEGIN helpers.js - This code is automatically updated, do not manually edit!
  4 | if (typeof window !== 'undefined' && !window.helpers) {
  5 | 
  6 | const generateFieldScopeSelector = () => {
  7 |     return `
  8 |         <div class="form-row form-row-radio">
  9 |                 <label for="node-input-scope"><i class="im im-scope-icon"></i> <span>Scope</span></label>
 10 |                 <label class="radio">
 11 |                 <input type="radio" name="node-input-scope-options" id="node-input-scope-user" value="user">
 12 |                 User
 13 |                 </label>
 14 |                 <label class="radio">
 15 |                 <input type="radio" name="node-input-scope-options" id="node-input-scope-product" value="product">
 16 |                 Product
 17 |                 </label>
 18 |                 <input type="hidden" id="node-input-scope">
 19 |         </div>
 20 |         <div class="form-row hidden" id="particle-scope-product">
 21 |                 <label for="node-input-scope"><i class="im im-product-icon"></i> <span>Product</span></label>
 22 |                 <input type="text" id="node-input-product" placeholder="Product slug or ID">
 23 |         </div>
 24 |     `;
 25 | };
 26 | 
 27 | const generateFieldSelect = (field) => {
 28 |     let html = `
 29 |         <div class="form-row">
 30 |                 <label for="node-input-${field.name}"><i class="${field.icon}"></i> ${field.title}</label>
 31 | 
 32 |                 <select id="node-input-${field.name}">
 33 |     `;
 34 | 
 35 |     field.values.forEach(val => {
 36 |         if (val.value === field.defaultValue) {
 37 |             html += `<option value="${val.value}" selected>${val.title}</option>`;
 38 |         } else {
 39 |             html += `<option value="${val.value}">${val.title}</option>`;
 40 |         }
 41 |     });
 42 | 
 43 |     html += `
 44 |             </select>
 45 |         </div>
 46 |     `;
 47 | 
 48 |     return html;
 49 | };
 50 | 
 51 | const generateField = (field) => {
 52 |     let html = '';
 53 | 
 54 |     if (field.type === 'scope-selector') {
 55 |         html = generateFieldScopeSelector(field);
 56 |     } else if (field.type === 'select') {
 57 |         html = generateFieldSelect(field);
 58 |     } else {
 59 |         html = `
 60 |             <div class="form-row">
 61 |                     <label for="node-input-${field.name}"><i class="${field.icon}"></i> ${field.title}</label>
 62 |                     <input type="${field.type === 'object' ? 'text' : field.type}" id="node-input-${field.name}" placeholder="${field.placeholder}">
 63 |             </div>
 64 |         `;
 65 |     }
 66 | 
 67 |     return html;
 68 | };
 69 | 
 70 | const generateEditTemplate = ({ name, fields }) => {
 71 |     let html = '';
 72 | 
 73 |     fields.forEach(field => {
 74 |         html += generateField(field);
 75 |     });
 76 | 
 77 |     $(`script[data-template-name="${name}"]`).html(html);
 78 | };
 79 | 
 80 | const generateDocumentation = ({ name, title, inputs, outputs, details, resources }) => {
 81 |     let html = `
 82 |                 <p>${title}</p>
 83 |         `;
 84 | 
 85 |     if (inputs) {
 86 |         html += `
 87 |             <h3>Inputs</h3>
 88 |             <dl class="message-properties">
 89 |         `;
 90 | 
 91 |         inputs.forEach(input => {
 92 |             html += `
 93 |                             <dt class="${input.optional ? 'optional' : ''}">${input.name} <span class="property-type">${input.type}</span></dt>
 94 |                             <dd>${input.description}</dd>
 95 |                     `;
 96 |         });
 97 |     }
 98 | 
 99 |     html += `
100 |                 </dl>
101 |     `;
102 | 
103 |     if (outputs) {
104 |         html += `
105 |                     <h3>Outputs</h3>
106 |                     <dl class="message-properties">
107 |         `;
108 | 
109 |         outputs.forEach(output => {
110 |             html += `
111 |                             <dt>${output.name} <span class="property-type">${output.type}</span></dt>
112 |                             <dd>${output.description}</dd>
113 |                     `;
114 |         });
115 | 
116 | 
117 |         html += `
118 |                     </dl>
119 |         `;
120 |     }
121 | 
122 |     html += `
123 |                 </dl>
124 |                 <h3>Details</h3>
125 |                 <p>${details}</p>
126 |                 <h3>Resources</h3>
127 |                 <ul>
128 |     `;
129 | 
130 | 
131 | 
132 |     resources.forEach(resource => {
133 |         html += `
134 |                         <li>
135 |                                 <a href="${resource.link}">${resource.name}</a> - ${resource.description}
136 |                         </li>
137 |                 `;
138 |     });
139 | 
140 |     html += '</ul>';
141 | 
142 |     $(`script[data-help-name="${name}"]`).html(html);
143 | };
144 | 
145 | const generateClientConfig = (config) => {
146 |     let nodeClient = Object.assign({}, config, {
147 |         category: 'particle',
148 |         color: '#C0DEED'
149 |     });
150 | 
151 |     if (config._scopeSelector === true) {
152 |         nodeClient.onScopeChange = function onscopechange() {
153 |             let stream = $('input[name=node-input-scope-options]:checked').val() || 'user';
154 | 
155 |             if (stream === 'product') {
156 |                 $('#particle-scope-product').removeClass('hidden');
157 |             } else {
158 |                 $('#particle-scope-product').addClass('hidden');
159 |                 $('#node-input-product').val('');
160 |             }
161 | 
162 |             $('#node-input-stream').val(stream);
163 |         };
164 | 
165 |         nodeClient.oneditprepare = function oneditprepare() {
166 |             $('input[name=node-input-scope-options]')
167 |                 .prop('checked', null)
168 |                 .change(nodeClient.onScopeChange.bind(this));
169 | 
170 |             const isProduct = $('#node-input-product').val();
171 | 
172 |             if (isProduct) {
173 |                 $('#node-input-scope-product').prop('checked', true);
174 |             } else {
175 |                 $('#node-input-scope-user').prop('checked', true);
176 |             }
177 | 
178 |             nodeClient.onScopeChange();
179 |         };
180 | 
181 |         nodeClient.oneditsave = function oneditsave() {
182 |             nodeClient.onScopeChange();
183 |         };
184 |     }
185 | 
186 |     return nodeClient;
187 | };
188 | 
189 | const addCSS = () => {
190 |     $('body').append(`
191 |         <link rel="stylesheet" href="https://s3.amazonaws.com/icomoon.io/49057/Dashboard/style.css?r41hg3">
192 |         <style>
193 |                 .form-row input[type="radio"] {
194 |                         width: auto !important;
195 |                 }
196 | 
197 |                 .form-row label i.fa {
198 |                         width: 14px;
199 |                 }
200 | 
201 |                 .form-row-radio {
202 |                         padding-top: 9px;
203 |                 }
204 |         </style>
205 |     `);
206 | };
207 | 
208 | const generateNodeFromDefinition = (name, definition) => {
209 |     generateEditTemplate(definition.editTemplate);
210 |     generateDocumentation(definition.documentation);
211 |     addCSS();
212 | 
213 |     RED.nodes.registerType(name, generateClientConfig(definition.client));
214 | };
215 | 
216 | /*global window*/
217 | window.helpers = {
218 |     generateEditTemplate,
219 |     generateDocumentation,
220 |     generateClientConfig,
221 |     generateNodeFromDefinition
222 | };
223 | 
224 | }    
225 | // END helpers.js - This code is automatically updated, do not manually edit!
226 | 
227 | 
228 | const functionEditTemplate = {
229 | 	name: 'particle-function',
230 | 	fields: [
231 | 		{ name: 'name', icon: 'icon-tag', title: 'Name', placeholder: 'Name', type: 'text' },
232 | 		{ name: 'auth', icon: 'fa fa-user', title: 'Auth', placeholder: 'Auth', type: 'text' },
233 | 		{ name: 'function', icon: 'im im-speech-bubble-icon', title: 'Function', placeholder: 'Function name', type: 'text' },
234 | 		{ name: 'argument', icon: 'im im-speech-bubble-icon', title: 'Argument', placeholder: 'Function argument', type: 'text' },
235 | 		{ name: 'device', icon: 'im im-devices-icon', title: 'Device', placeholder: 'Device name or ID', type: 'text' },
236 | 		{ type: 'scope-selector' }
237 | 	]
238 | };
239 | 
240 | const functionDocumentation = {
241 | 	name: 'particle-function',
242 | 	title: 'Call a cloud function on a Particle device',
243 | 	inputs: [
244 | 		{ name: 'function', type: 'string', description: 'If not configured in node properties, this optional property sets the function name to call', optional: true },
245 | 		{ name: 'argument', type: 'string', description: 'If not configured in node properties, this optional property sets the argument to pass to the device when calling the cloud function', optional: true },
246 | 		{ name: 'device', type: 'string', description: 'If not configured in the node, this property sets the device name or ID for which to call the function', optional: true }
247 | 	],
248 | 	outputs: [
249 | 		{ name: 'payload', type: 'string', description: 'The result of the called function from the device' },
250 | 		{ name: 'function', type: 'string', description: 'The name of the function that was called' },
251 | 		{ name: 'device', type: 'string', description: 'The name or ID of the device that was queried' }
252 | 	],
253 | 	details: `
254 | 		<p>Cloud functions allow you to tell a device to take an action remotely. They are defined in application firmware using <code>Particle.function()</code>.</p>
255 | 		<p>This node is intended to be placed in the middle of a flow to call a cloud function on a Particle device.</p>
256 | 		<p>Scope the function call to a device either owned by your <b>user</b> account or a device in a <b>product</b> fleet.
257 | 		If calling a function on a device in a product, providing the product slug or ID is required.</p>
258 | 		<p>You may set the function name to call, the argument to pass, and the targeted device either as part of node properties, or by passing <code>msg.function</code>, <code>msg.argument</code>, or <code>msg.device</code> as an input to this node, respectively.</p>
259 | 		<p>When the function is called, the result will be appended to to the outbound <code>msg</code> object as <code>msg.payload</code>.
260 | 		The function name and the device name/ID will also be appended to the outbound <code>msg</code> as <code>msg.function</code> and <code>msg.device</code>, respectively.</p>
261 | 	`,
262 | 	resources: [
263 | 		{ name: 'Particle.function() docs', link: 'https://docs.particle.io/reference/firmware/#particle-function-', description: 'Describes how to define cloud functions in application firmware' }
264 | 	]
265 | };
266 | 
267 | const functionClient = {
268 | 	defaults: {
269 | 		name: { value: '' },
270 | 		auth: { type: 'particle-config', required: true },
271 | 		function: {},
272 | 		argument: {},
273 | 		scope: { value: 'user', required: true },
274 | 		device: {},
275 | 		product: {},
276 | 		refresh: {}
277 | 	},
278 | 	inputs: 1,
279 | 	outputs: 1,
280 | 	icon: 'particle.png',
281 | 	align: 'left',
282 | 	paletteLabel: function() {
283 | 		return 'function';
284 | 	},
285 | 	label: function label() {
286 | 		if (this.name) {
287 | 			return this.name;
288 | 		}
289 | 
290 | 		if (this.function) {
291 | 			return `function ${this.function}`;
292 | 		}
293 | 
294 | 		return functionClient.paletteLabel();
295 | 	},
296 | 	_scopeSelector: true
297 | };
298 | 
299 | /*global window*/
300 | window.functionNodeDefinition = {
301 | 	editTemplate:functionEditTemplate,
302 | 	documentation:functionDocumentation,
303 | 	client:functionClient
304 | };
305 | 
306 | window.helpers.generateNodeFromDefinition('particle-function', window.functionNodeDefinition);
307 | </script>
308 | 
309 | <script type="text/x-red" data-template-name="particle-function"></script>
310 | <script type="text/x-red" data-help-name="particle-function"></script>


--------------------------------------------------------------------------------
/nodes/function/function.js:
--------------------------------------------------------------------------------
 1 | 'use strict';
 2 | 
 3 | const ParticleBaseNode = require('../../src/particle-base-node');
 4 | 
 5 | module.exports = (RED) => {
 6 | 	function ParticleFunctionNode(node) {
 7 | 		RED.nodes.createNode(this, node);
 8 | 
 9 | 		new ParticleBaseNode({
10 | 			self: this,
11 | 			node: node,
12 | 			RED: RED,
13 | 			properties: ['name', 'scope', 'device', 'product', 'function', 'argument'],
14 | 			inputProperties: ['device', 'function', 'argument'],
15 | 			functionName: 'callFunction',
16 | 			functionArguments: [
17 | 				{ key: 'deviceId', value: 'device' },
18 | 				{ key: 'name', value: 'function' },
19 | 				{ key: 'argument', value: 'argument' },
20 | 				{ key: 'product', value: 'product' }
21 | 			],
22 | 			mandatoryArguments: ['deviceId', 'name'],
23 | 			success: {
24 | 				fields: [
25 | 					{ key: 'payload' },
26 | 					{ key: 'function', value: 'function' },
27 | 					{ key: 'device', value: 'device' }
28 | 				],
29 | 				status: 'called'
30 | 			},
31 | 			info: {
32 | 				status: 'calling'
33 | 			},
34 | 			error: {
35 | 				status: 'failed',
36 | 				onRuntime: 'Failed to call function'
37 | 			}
38 | 		});
39 | 	}
40 | 
41 | 	RED.nodes.registerType('particle-function', ParticleFunctionNode);
42 | 
43 | };
44 | 


--------------------------------------------------------------------------------
/nodes/function/icons/particle.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/particle-iot/node-red-contrib-particle-official/62bd7258e41946e979722db8907deb7ca148dd23/nodes/function/icons/particle.png


--------------------------------------------------------------------------------
/nodes/function/icons/particle@2x.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/particle-iot/node-red-contrib-particle-official/62bd7258e41946e979722db8907deb7ca148dd23/nodes/function/icons/particle@2x.png


--------------------------------------------------------------------------------
/nodes/publish/icons/particle.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/particle-iot/node-red-contrib-particle-official/62bd7258e41946e979722db8907deb7ca148dd23/nodes/publish/icons/particle.png


--------------------------------------------------------------------------------
/nodes/publish/icons/particle@2x.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/particle-iot/node-red-contrib-particle-official/62bd7258e41946e979722db8907deb7ca148dd23/nodes/publish/icons/particle@2x.png


--------------------------------------------------------------------------------
/nodes/publish/publish.html:
--------------------------------------------------------------------------------
  1 | <link rel="stylesheet" href="https://s3.amazonaws.com/icomoon.io/49057/Dashboard/style.css?r41hg3">
  2 | <style>
  3 |     .form-row input[type="radio"] {
  4 |         width: auto !important;
  5 |     }
  6 | 
  7 |     .form-row label i.fa {
  8 |         width: 14px;
  9 |     }
 10 | 
 11 |     .form-row-radio {
 12 |         padding-top: 9px;
 13 |     }
 14 | </style>
 15 | 
 16 | <script>
 17 | // BEGIN helpers.js - This code is automatically updated, do not manually edit!
 18 | if (typeof window !== 'undefined' && !window.helpers) {
 19 | 
 20 | const generateFieldScopeSelector = () => {
 21 |     return `
 22 |         <div class="form-row form-row-radio">
 23 |                 <label for="node-input-scope"><i class="im im-scope-icon"></i> <span>Scope</span></label>
 24 |                 <label class="radio">
 25 |                 <input type="radio" name="node-input-scope-options" id="node-input-scope-user" value="user">
 26 |                 User
 27 |                 </label>
 28 |                 <label class="radio">
 29 |                 <input type="radio" name="node-input-scope-options" id="node-input-scope-product" value="product">
 30 |                 Product
 31 |                 </label>
 32 |                 <input type="hidden" id="node-input-scope">
 33 |         </div>
 34 |         <div class="form-row hidden" id="particle-scope-product">
 35 |                 <label for="node-input-scope"><i class="im im-product-icon"></i> <span>Product</span></label>
 36 |                 <input type="text" id="node-input-product" placeholder="Product slug or ID">
 37 |         </div>
 38 |     `;
 39 | };
 40 | 
 41 | const generateFieldSelect = (field) => {
 42 |     let html = `
 43 |         <div class="form-row">
 44 |                 <label for="node-input-${field.name}"><i class="${field.icon}"></i> ${field.title}</label>
 45 | 
 46 |                 <select id="node-input-${field.name}">
 47 |     `;
 48 | 
 49 |     field.values.forEach(val => {
 50 |         if (val.value === field.defaultValue) {
 51 |             html += `<option value="${val.value}" selected>${val.title}</option>`;
 52 |         } else {
 53 |             html += `<option value="${val.value}">${val.title}</option>`;
 54 |         }
 55 |     });
 56 | 
 57 |     html += `
 58 |             </select>
 59 |         </div>
 60 |     `;
 61 | 
 62 |     return html;
 63 | };
 64 | 
 65 | const generateField = (field) => {
 66 |     let html = '';
 67 | 
 68 |     if (field.type === 'scope-selector') {
 69 |         html = generateFieldScopeSelector(field);
 70 |     } else if (field.type === 'select') {
 71 |         html = generateFieldSelect(field);
 72 |     } else {
 73 |         html = `
 74 |             <div class="form-row">
 75 |                     <label for="node-input-${field.name}"><i class="${field.icon}"></i> ${field.title}</label>
 76 |                     <input type="${field.type === 'object' ? 'text' : field.type}" id="node-input-${field.name}" placeholder="${field.placeholder}">
 77 |             </div>
 78 |         `;
 79 |     }
 80 | 
 81 |     return html;
 82 | };
 83 | 
 84 | const generateEditTemplate = ({ name, fields }) => {
 85 |     let html = '';
 86 | 
 87 |     fields.forEach(field => {
 88 |         html += generateField(field);
 89 |     });
 90 | 
 91 |     $(`script[data-template-name="${name}"]`).html(html);
 92 | };
 93 | 
 94 | const generateDocumentation = ({ name, title, inputs, outputs, details, resources }) => {
 95 |     let html = `
 96 |                 <p>${title}</p>
 97 |         `;
 98 | 
 99 |     if (inputs) {
100 |         html += `
101 |             <h3>Inputs</h3>
102 |             <dl class="message-properties">
103 |         `;
104 | 
105 |         inputs.forEach(input => {
106 |             html += `
107 |                             <dt class="${input.optional ? 'optional' : ''}">${input.name} <span class="property-type">${input.type}</span></dt>
108 |                             <dd>${input.description}</dd>
109 |                     `;
110 |         });
111 |     }
112 | 
113 |     html += `
114 |                 </dl>
115 |     `;
116 | 
117 |     if (outputs) {
118 |         html += `
119 |                     <h3>Outputs</h3>
120 |                     <dl class="message-properties">
121 |         `;
122 | 
123 |         outputs.forEach(output => {
124 |             html += `
125 |                             <dt>${output.name} <span class="property-type">${output.type}</span></dt>
126 |                             <dd>${output.description}</dd>
127 |                     `;
128 |         });
129 | 
130 | 
131 |         html += `
132 |                     </dl>
133 |         `;
134 |     }
135 | 
136 |     html += `
137 |                 </dl>
138 |                 <h3>Details</h3>
139 |                 <p>${details}</p>
140 |                 <h3>Resources</h3>
141 |                 <ul>
142 |     `;
143 | 
144 | 
145 | 
146 |     resources.forEach(resource => {
147 |         html += `
148 |                         <li>
149 |                                 <a href="${resource.link}">${resource.name}</a> - ${resource.description}
150 |                         </li>
151 |                 `;
152 |     });
153 | 
154 |     html += '</ul>';
155 | 
156 |     $(`script[data-help-name="${name}"]`).html(html);
157 | };
158 | 
159 | const generateClientConfig = (config) => {
160 |     let nodeClient = Object.assign({}, config, {
161 |         category: 'particle',
162 |         color: '#C0DEED'
163 |     });
164 | 
165 |     if (config._scopeSelector === true) {
166 |         nodeClient.onScopeChange = function onscopechange() {
167 |             let stream = $('input[name=node-input-scope-options]:checked').val() || 'user';
168 | 
169 |             if (stream === 'product') {
170 |                 $('#particle-scope-product').removeClass('hidden');
171 |             } else {
172 |                 $('#particle-scope-product').addClass('hidden');
173 |                 $('#node-input-product').val('');
174 |             }
175 | 
176 |             $('#node-input-stream').val(stream);
177 |         };
178 | 
179 |         nodeClient.oneditprepare = function oneditprepare() {
180 |             $('input[name=node-input-scope-options]')
181 |                 .prop('checked', null)
182 |                 .change(nodeClient.onScopeChange.bind(this));
183 | 
184 |             const isProduct = $('#node-input-product').val();
185 | 
186 |             if (isProduct) {
187 |                 $('#node-input-scope-product').prop('checked', true);
188 |             } else {
189 |                 $('#node-input-scope-user').prop('checked', true);
190 |             }
191 | 
192 |             nodeClient.onScopeChange();
193 |         };
194 | 
195 |         nodeClient.oneditsave = function oneditsave() {
196 |             nodeClient.onScopeChange();
197 |         };
198 |     }
199 | 
200 |     return nodeClient;
201 | };
202 | 
203 | const addCSS = () => {
204 |     $('body').append(`
205 |         <link rel="stylesheet" href="https://s3.amazonaws.com/icomoon.io/49057/Dashboard/style.css?r41hg3">
206 |         <style>
207 |                 .form-row input[type="radio"] {
208 |                         width: auto !important;
209 |                 }
210 | 
211 |                 .form-row label i.fa {
212 |                         width: 14px;
213 |                 }
214 | 
215 |                 .form-row-radio {
216 |                         padding-top: 9px;
217 |                 }
218 |         </style>
219 |     `);
220 | };
221 | 
222 | const generateNodeFromDefinition = (name, definition) => {
223 |     generateEditTemplate(definition.editTemplate);
224 |     generateDocumentation(definition.documentation);
225 |     addCSS();
226 | 
227 |     RED.nodes.registerType(name, generateClientConfig(definition.client));
228 | };
229 | 
230 | /*global window*/
231 | window.helpers = {
232 |     generateEditTemplate,
233 |     generateDocumentation,
234 |     generateClientConfig,
235 |     generateNodeFromDefinition
236 | };
237 | 
238 | }    
239 | // END helpers.js - This code is automatically updated, do not manually edit!
240 | 
241 | 
242 | const publishEditTemplate = {
243 | 	name: 'particle-publish',
244 | 	fields: [
245 | 		{ name: 'name', icon: 'icon-tag', title: 'Name', placeholder: 'Name', type: 'text' },
246 | 		{ name: 'auth', icon: 'fa fa-user', title: 'Auth', placeholder: 'Auth', type: 'text' },
247 | 		{ name: 'event', icon: 'im im-speech-bubble-icon', title: 'Event', placeholder: 'Event name', type: 'text' },
248 | 		{ type: 'scope-selector' }
249 | 	]
250 | };
251 | 
252 | const publishDocumentation = {
253 | 	name: 'particle-publish',
254 | 	title: 'Publish a Particle event from a flow',
255 | 	inputs: [
256 | 		{ name: 'event', type: 'string', description: 'If not configured in the node, this optional property sets the name of the event to publish', optional: true },
257 | 		{ name: 'payload', type: 'string', description: 'The data payload that will be sent along with the published Particle event', optional: true }
258 | 	],
259 | 	details: `
260 | 		<p>Publishing Particle events allow you to send messages through the Device Coud onto subscribers like Particle devices.</p>
261 | 		<p>This node is intended to be placed at the end of a flow to publish a Particle event under certain conditions.</p>
262 | 		<p>Scope the publish either to a <b>user</b> or <b>product</b> event stream. Choosing the user stream will publish the event to devices owned by the authenticated user. Choosing the product stream will publish the event to devices associated with the product fleet.
263 | 		If publishing to a product event stream, providing the product slug or ID is required.
264 | 		</p>
265 | 		<p>You may set the event name to publish either as part of node properties, or by passing <code>msg.event</code> as an input to this node</p>
266 | 		<p>If you would like to send a data payload along with the event, pass <code>msg.payload</code> as an input to this node.</p>
267 | 	`,
268 | 	resources: [
269 | 		{ name: 'Particle.subscribe() docs', link: 'https://docs.particle.io/reference/firmware/#particle-subscribe-', description: 'Describes how listen for events published by this node in device firmware' },
270 | 		{ name: 'Event stream API docs', link: 'https://docs.particle.io/reference/api/#events', description: 'Learn more about the event stream that integrates with this node' }
271 | 	]
272 | };
273 | 
274 | const publishClient = {
275 | 	defaults: {
276 | 		name: { value: '' },
277 | 		auth: { type: 'particle-config', required: true },
278 | 		scope: { value: 'user', required: true },
279 | 		product: {},
280 | 		event: {}
281 | 	},
282 | 	inputs: 1,
283 | 	outputs: 0,
284 | 	icon: 'particle.png',
285 | 	align: 'right',
286 | 	paletteLabel: function () {
287 | 		return 'publish';
288 | 	},
289 | 	label: function label() {
290 | 		if (this.name) {
291 | 			return this.name;
292 | 		}
293 | 
294 | 		if (this.event) {
295 | 			return 'publish "' + this.event + '" event';
296 | 		}
297 | 
298 | 		return publishClient.paletteLabel();
299 | 	},
300 | 	_scopeSelector: true
301 | };
302 | 
303 | /*global window*/
304 | window.publishNodeDefinition = {
305 | 	editTemplate:publishEditTemplate,
306 | 	documentation:publishDocumentation,
307 | 	client:publishClient
308 | };
309 | 
310 | window.helpers.generateNodeFromDefinition('particle-publish', window.publishNodeDefinition);
311 | </script>
312 | 
313 | <script type="text/x-red" data-template-name="particle-publish"></script>
314 | <script type="text/x-red" data-help-name="particle-publish"></script>
315 | 


--------------------------------------------------------------------------------
/nodes/publish/publish.js:
--------------------------------------------------------------------------------
 1 | 'use strict';
 2 | 
 3 | const ParticleBaseNode = require('../../src/particle-base-node');
 4 | 
 5 | module.exports = (RED) => {
 6 | 	function ParticlePublishNode(node) {
 7 | 		RED.nodes.createNode(this, node);
 8 | 
 9 | 		new ParticleBaseNode({
10 | 			self: this,
11 | 			node: node,
12 | 			RED: RED,
13 | 			properties: ['name', 'scope', 'product', 'event', 'payload'],
14 | 			inputProperties: ['event', 'payload'],
15 | 			functionName: 'publishEvent',
16 | 			functionArguments: [
17 | 				{ key: 'name', value: 'event' },
18 | 				{ key: 'product', value: 'product' },
19 | 				{ key: 'data', value: 'payload' },
20 | 				{ key: 'isPrivate', defaultValue: true }
21 | 			],
22 | 			mandatoryArguments: ['name'],
23 | 			success: {
24 | 				status: 'published'
25 | 			},
26 | 			info: {
27 | 				status: 'publishing'
28 | 			},
29 | 			error: {
30 | 				status: 'failed',
31 | 				onRuntime: 'Failed to publish event'
32 | 			}
33 | 		});
34 | 	}
35 | 
36 | 	RED.nodes.registerType('particle-publish', ParticlePublishNode);
37 | 
38 | };
39 | 


--------------------------------------------------------------------------------
/nodes/subscribe/icons/particle.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/particle-iot/node-red-contrib-particle-official/62bd7258e41946e979722db8907deb7ca148dd23/nodes/subscribe/icons/particle.png


--------------------------------------------------------------------------------
/nodes/subscribe/icons/particle@2x.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/particle-iot/node-red-contrib-particle-official/62bd7258e41946e979722db8907deb7ca148dd23/nodes/subscribe/icons/particle@2x.png


--------------------------------------------------------------------------------
/nodes/subscribe/subscribe.html:
--------------------------------------------------------------------------------
  1 | 
  2 | <script>
  3 | // BEGIN helpers.js - This code is automatically updated, do not manually edit!
  4 | if (typeof window !== 'undefined' && !window.helpers) {
  5 | 
  6 | const generateFieldScopeSelector = () => {
  7 |     return `
  8 |         <div class="form-row form-row-radio">
  9 |                 <label for="node-input-scope"><i class="im im-scope-icon"></i> <span>Scope</span></label>
 10 |                 <label class="radio">
 11 |                 <input type="radio" name="node-input-scope-options" id="node-input-scope-user" value="user">
 12 |                 User
 13 |                 </label>
 14 |                 <label class="radio">
 15 |                 <input type="radio" name="node-input-scope-options" id="node-input-scope-product" value="product">
 16 |                 Product
 17 |                 </label>
 18 |                 <input type="hidden" id="node-input-scope">
 19 |         </div>
 20 |         <div class="form-row hidden" id="particle-scope-product">
 21 |                 <label for="node-input-scope"><i class="im im-product-icon"></i> <span>Product</span></label>
 22 |                 <input type="text" id="node-input-product" placeholder="Product slug or ID">
 23 |         </div>
 24 |     `;
 25 | };
 26 | 
 27 | const generateFieldSelect = (field) => {
 28 |     let html = `
 29 |         <div class="form-row">
 30 |                 <label for="node-input-${field.name}"><i class="${field.icon}"></i> ${field.title}</label>
 31 | 
 32 |                 <select id="node-input-${field.name}">
 33 |     `;
 34 | 
 35 |     field.values.forEach(val => {
 36 |         if (val.value === field.defaultValue) {
 37 |             html += `<option value="${val.value}" selected>${val.title}</option>`;
 38 |         } else {
 39 |             html += `<option value="${val.value}">${val.title}</option>`;
 40 |         }
 41 |     });
 42 | 
 43 |     html += `
 44 |             </select>
 45 |         </div>
 46 |     `;
 47 | 
 48 |     return html;
 49 | };
 50 | 
 51 | const generateField = (field) => {
 52 |     let html = '';
 53 | 
 54 |     if (field.type === 'scope-selector') {
 55 |         html = generateFieldScopeSelector(field);
 56 |     } else if (field.type === 'select') {
 57 |         html = generateFieldSelect(field);
 58 |     } else {
 59 |         html = `
 60 |             <div class="form-row">
 61 |                     <label for="node-input-${field.name}"><i class="${field.icon}"></i> ${field.title}</label>
 62 |                     <input type="${field.type === 'object' ? 'text' : field.type}" id="node-input-${field.name}" placeholder="${field.placeholder}">
 63 |             </div>
 64 |         `;
 65 |     }
 66 | 
 67 |     return html;
 68 | };
 69 | 
 70 | const generateEditTemplate = ({ name, fields }) => {
 71 |     let html = '';
 72 | 
 73 |     fields.forEach(field => {
 74 |         html += generateField(field);
 75 |     });
 76 | 
 77 |     $(`script[data-template-name="${name}"]`).html(html);
 78 | };
 79 | 
 80 | const generateDocumentation = ({ name, title, inputs, outputs, details, resources }) => {
 81 |     let html = `
 82 |                 <p>${title}</p>
 83 |         `;
 84 | 
 85 |     if (inputs) {
 86 |         html += `
 87 |             <h3>Inputs</h3>
 88 |             <dl class="message-properties">
 89 |         `;
 90 | 
 91 |         inputs.forEach(input => {
 92 |             html += `
 93 |                             <dt class="${input.optional ? 'optional' : ''}">${input.name} <span class="property-type">${input.type}</span></dt>
 94 |                             <dd>${input.description}</dd>
 95 |                     `;
 96 |         });
 97 |     }
 98 | 
 99 |     html += `
100 |                 </dl>
101 |     `;
102 | 
103 |     if (outputs) {
104 |         html += `
105 |                     <h3>Outputs</h3>
106 |                     <dl class="message-properties">
107 |         `;
108 | 
109 |         outputs.forEach(output => {
110 |             html += `
111 |                             <dt>${output.name} <span class="property-type">${output.type}</span></dt>
112 |                             <dd>${output.description}</dd>
113 |                     `;
114 |         });
115 | 
116 | 
117 |         html += `
118 |                     </dl>
119 |         `;
120 |     }
121 | 
122 |     html += `
123 |                 </dl>
124 |                 <h3>Details</h3>
125 |                 <p>${details}</p>
126 |                 <h3>Resources</h3>
127 |                 <ul>
128 |     `;
129 | 
130 | 
131 | 
132 |     resources.forEach(resource => {
133 |         html += `
134 |                         <li>
135 |                                 <a href="${resource.link}">${resource.name}</a> - ${resource.description}
136 |                         </li>
137 |                 `;
138 |     });
139 | 
140 |     html += '</ul>';
141 | 
142 |     $(`script[data-help-name="${name}"]`).html(html);
143 | };
144 | 
145 | const generateClientConfig = (config) => {
146 |     let nodeClient = Object.assign({}, config, {
147 |         category: 'particle',
148 |         color: '#C0DEED'
149 |     });
150 | 
151 |     if (config._scopeSelector === true) {
152 |         nodeClient.onScopeChange = function onscopechange() {
153 |             let stream = $('input[name=node-input-scope-options]:checked').val() || 'user';
154 | 
155 |             if (stream === 'product') {
156 |                 $('#particle-scope-product').removeClass('hidden');
157 |             } else {
158 |                 $('#particle-scope-product').addClass('hidden');
159 |                 $('#node-input-product').val('');
160 |             }
161 | 
162 |             $('#node-input-stream').val(stream);
163 |         };
164 | 
165 |         nodeClient.oneditprepare = function oneditprepare() {
166 |             $('input[name=node-input-scope-options]')
167 |                 .prop('checked', null)
168 |                 .change(nodeClient.onScopeChange.bind(this));
169 | 
170 |             const isProduct = $('#node-input-product').val();
171 | 
172 |             if (isProduct) {
173 |                 $('#node-input-scope-product').prop('checked', true);
174 |             } else {
175 |                 $('#node-input-scope-user').prop('checked', true);
176 |             }
177 | 
178 |             nodeClient.onScopeChange();
179 |         };
180 | 
181 |         nodeClient.oneditsave = function oneditsave() {
182 |             nodeClient.onScopeChange();
183 |         };
184 |     }
185 | 
186 |     return nodeClient;
187 | };
188 | 
189 | const addCSS = () => {
190 |     $('body').append(`
191 |         <link rel="stylesheet" href="https://s3.amazonaws.com/icomoon.io/49057/Dashboard/style.css?r41hg3">
192 |         <style>
193 |                 .form-row input[type="radio"] {
194 |                         width: auto !important;
195 |                 }
196 | 
197 |                 .form-row label i.fa {
198 |                         width: 14px;
199 |                 }
200 | 
201 |                 .form-row-radio {
202 |                         padding-top: 9px;
203 |                 }
204 |         </style>
205 |     `);
206 | };
207 | 
208 | const generateNodeFromDefinition = (name, definition) => {
209 |     generateEditTemplate(definition.editTemplate);
210 |     generateDocumentation(definition.documentation);
211 |     addCSS();
212 | 
213 |     RED.nodes.registerType(name, generateClientConfig(definition.client));
214 | };
215 | 
216 | /*global window*/
217 | window.helpers = {
218 |     generateEditTemplate,
219 |     generateDocumentation,
220 |     generateClientConfig,
221 |     generateNodeFromDefinition
222 | };
223 | 
224 | }    
225 | // END helpers.js - This code is automatically updated, do not manually edit!
226 | 
227 | 
228 | const subscribeEditTemplate = {
229 | 	name: 'particle-subscribe',
230 | 	fields: [
231 | 		{ name: 'name', icon: 'icon-tag', title: 'Name', placeholder: 'Name', type: 'text' },
232 | 		{ name: 'auth', icon: 'fa fa-user', title: 'Auth', placeholder: 'Auth', type: 'text' },
233 | 		{ name: 'event', icon: 'im im-speech-bubble-icon', title: 'Event', placeholder: 'Event name', type: 'text' },
234 | 		{ name: 'device', icon: 'im im-devices-icon', title: 'Device', placeholder: 'Device name or ID', type: 'text' },
235 | 		{ type: 'scope-selector' }
236 | 	]
237 | };
238 | 
239 | const subscribeDocumentation = {
240 | 	name: 'particle-subscribe',
241 | 	title: 'Subscribe to Particle events',
242 | 	outputs: [
243 | 		{ name: 'event', type: 'string', description: 'The name of the Particle event' },
244 | 		{ name: 'payload', type: 'string', description: 'The data payload sent along with the Particle event' },
245 | 		{ name: 'published_at', type: 'string', description: 'The timestamp of when the Particle event was sent' },
246 | 		{ name: 'device', type: 'string', description: 'The ID of the device that published the event' }
247 | 	],
248 | 	details: `
249 | 		<p>Subscribing to Particle events allows you to listen for events from Device Cloud publishers like Particle devices.</p>
250 | 		<p>This node is intended to be placed at the beginning of flows to trigger business logic based on an emitted Particle event.</p>
251 | 		<p>Scope the publish either to a <b>user</b> or <b>product</b> event stream. Choosing the user stream will publish the event to devices owned by the authenticated user. Choosing the product stream will publish the event to devices associated with the product fleet.
252 | 		If publishing to a product event stream, providing the product slug or ID is required.
253 | 		</p>
254 | 		<p>Optionally, you may filter the event stream to certain <b>event names</b> and/or by <b>device</b>.
255 | 		Note that event filtering uses <i>prefix matching</i>, meaning that all events starting with the provided event name will be injected into the flow.
256 | 		For device filtering, you can pass either a device ID or name.
257 | 		</p>
258 |   `,
259 | 	resources: [
260 | 		{ name: 'Particle.subscribe() docs', link: 'https://docs.particle.io/reference/firmware/#particle-subscribe-', description: 'Describes how listen for events published by this node in device firmware' },
261 | 		{ name: 'Event stream API docs', link: 'https://docs.particle.io/reference/api/#events', description: 'Learn more about the event stream that integrates with this node' }
262 | 	]
263 | };
264 | 
265 | const subscribeClient = {
266 | 	defaults: {
267 | 		name: { value: '' },
268 | 		auth: { type: 'particle-config', required: true },
269 | 		scope: { value: 'user', required: true },
270 | 		product: {},
271 | 		event: {},
272 | 		device: {}
273 | 	},
274 | 	inputs: 0,
275 | 	outputs: 1,
276 | 	icon: 'particle.png',
277 | 	paletteLabel: function () {
278 | 		return 'subscribe';
279 | 	},
280 | 	label: function label() {
281 | 		if (this.name) {
282 | 			return this.name;
283 | 		}
284 | 		if (this.event) {
285 | 			return 'subscribe to "' + this.event + '"';
286 | 		}
287 | 		return subscribeClient.paletteLabel();
288 | 	},
289 | 	_scopeSelector: true
290 | };
291 | 
292 | const subscribeDefinition = {
293 | 	name: 'subscribe',
294 | 	nodeName: 'particle-subscribe',
295 | 	editTemplate:subscribeEditTemplate,
296 | 	documentation:subscribeDocumentation,
297 | 	client:subscribeClient
298 | };
299 | 
300 | if (typeof window !== 'undefined') {
301 | 	/*global window*/
302 | 	window.subscribeNodeDefinition = subscribeDefinition;
303 | }
304 | 
305 | if (typeof module !== 'undefined') {
306 | 	module.exports = subscribeDefinition;
307 | }
308 | 
309 | window.helpers.generateNodeFromDefinition('particle-subscribe', window.subscribeNodeDefinition);
310 | </script>
311 | 
312 | <script type="text/x-red" data-template-name="particle-subscribe"></script>
313 | <script type="text/x-red" data-help-name="particle-subscribe"></script>
314 | 


--------------------------------------------------------------------------------
/nodes/subscribe/subscribe.js:
--------------------------------------------------------------------------------
 1 | 'use strict';
 2 | 
 3 | const helpers = require('../../src/helpers');
 4 | const ParticleBaseNode = require('../../src/particle-base-node');
 5 | 
 6 | module.exports = (RED) => {
 7 | 	function ParticleSubscribeNode(node) {
 8 | 		RED.nodes.createNode(this, node);
 9 | 
10 | 		new ParticleBaseNode({
11 | 			self: this,
12 | 			node: node,
13 | 			RED: RED,
14 | 			properties: ['name', 'scope', 'device', 'product', 'event'],
15 | 			functionName: 'listenToEventStream',
16 | 			functionArguments: [
17 | 				{ key: 'deviceId', customValue: ({ device, product }) => {
18 | 					if (product) {
19 | 						return device === '' ? undefined : device;
20 | 					} else {
21 | 						return device === '' ? 'mine' : device;
22 | 					}
23 | 				} },
24 | 				{ key: 'name', value: 'event' },
25 | 				{ key: 'product', value: 'product' },
26 | 				{ key: 'onEvent', defaultValue: (data) => {
27 | 					helpers.onSuccess({ status: this.status.bind(this), message: 'new event' });
28 | 
29 | 					this.send({
30 | 						event: data.name,
31 | 						payload: data.data,
32 | 						published_at: data.published_at,
33 | 						device: data.coreid
34 | 					});
35 | 				} }
36 | 			],
37 | 			mandatoryArguments: [],
38 | 			runOnLoad: true,
39 | 			info: {
40 | 				status: 'setting up stream'
41 | 			},
42 | 			error: {
43 | 				status: 'failed to set up stream',
44 | 				onRuntime: 'Failed to set up stream'
45 | 			}
46 | 		});
47 | 	}
48 | 
49 | 	RED.nodes.registerType('particle-subscribe', ParticleSubscribeNode);
50 | 
51 | };
52 | 


--------------------------------------------------------------------------------
/nodes/variable/icons/particle.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/particle-iot/node-red-contrib-particle-official/62bd7258e41946e979722db8907deb7ca148dd23/nodes/variable/icons/particle.png


--------------------------------------------------------------------------------
/nodes/variable/icons/particle@2x.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/particle-iot/node-red-contrib-particle-official/62bd7258e41946e979722db8907deb7ca148dd23/nodes/variable/icons/particle@2x.png


--------------------------------------------------------------------------------
/nodes/variable/variable.html:
--------------------------------------------------------------------------------
  1 | 
  2 | <script>
  3 | // BEGIN helpers.js - This code is automatically updated, do not manually edit!
  4 | if (typeof window !== 'undefined' && !window.helpers) {
  5 | 
  6 | const generateFieldScopeSelector = () => {
  7 |     return `
  8 |         <div class="form-row form-row-radio">
  9 |                 <label for="node-input-scope"><i class="im im-scope-icon"></i> <span>Scope</span></label>
 10 |                 <label class="radio">
 11 |                 <input type="radio" name="node-input-scope-options" id="node-input-scope-user" value="user">
 12 |                 User
 13 |                 </label>
 14 |                 <label class="radio">
 15 |                 <input type="radio" name="node-input-scope-options" id="node-input-scope-product" value="product">
 16 |                 Product
 17 |                 </label>
 18 |                 <input type="hidden" id="node-input-scope">
 19 |         </div>
 20 |         <div class="form-row hidden" id="particle-scope-product">
 21 |                 <label for="node-input-scope"><i class="im im-product-icon"></i> <span>Product</span></label>
 22 |                 <input type="text" id="node-input-product" placeholder="Product slug or ID">
 23 |         </div>
 24 |     `;
 25 | };
 26 | 
 27 | const generateFieldSelect = (field) => {
 28 |     let html = `
 29 |         <div class="form-row">
 30 |                 <label for="node-input-${field.name}"><i class="${field.icon}"></i> ${field.title}</label>
 31 | 
 32 |                 <select id="node-input-${field.name}">
 33 |     `;
 34 | 
 35 |     field.values.forEach(val => {
 36 |         if (val.value === field.defaultValue) {
 37 |             html += `<option value="${val.value}" selected>${val.title}</option>`;
 38 |         } else {
 39 |             html += `<option value="${val.value}">${val.title}</option>`;
 40 |         }
 41 |     });
 42 | 
 43 |     html += `
 44 |             </select>
 45 |         </div>
 46 |     `;
 47 | 
 48 |     return html;
 49 | };
 50 | 
 51 | const generateField = (field) => {
 52 |     let html = '';
 53 | 
 54 |     if (field.type === 'scope-selector') {
 55 |         html = generateFieldScopeSelector(field);
 56 |     } else if (field.type === 'select') {
 57 |         html = generateFieldSelect(field);
 58 |     } else {
 59 |         html = `
 60 |             <div class="form-row">
 61 |                     <label for="node-input-${field.name}"><i class="${field.icon}"></i> ${field.title}</label>
 62 |                     <input type="${field.type === 'object' ? 'text' : field.type}" id="node-input-${field.name}" placeholder="${field.placeholder}">
 63 |             </div>
 64 |         `;
 65 |     }
 66 | 
 67 |     return html;
 68 | };
 69 | 
 70 | const generateEditTemplate = ({ name, fields }) => {
 71 |     let html = '';
 72 | 
 73 |     fields.forEach(field => {
 74 |         html += generateField(field);
 75 |     });
 76 | 
 77 |     $(`script[data-template-name="${name}"]`).html(html);
 78 | };
 79 | 
 80 | const generateDocumentation = ({ name, title, inputs, outputs, details, resources }) => {
 81 |     let html = `
 82 |                 <p>${title}</p>
 83 |         `;
 84 | 
 85 |     if (inputs) {
 86 |         html += `
 87 |             <h3>Inputs</h3>
 88 |             <dl class="message-properties">
 89 |         `;
 90 | 
 91 |         inputs.forEach(input => {
 92 |             html += `
 93 |                             <dt class="${input.optional ? 'optional' : ''}">${input.name} <span class="property-type">${input.type}</span></dt>
 94 |                             <dd>${input.description}</dd>
 95 |                     `;
 96 |         });
 97 |     }
 98 | 
 99 |     html += `
100 |                 </dl>
101 |     `;
102 | 
103 |     if (outputs) {
104 |         html += `
105 |                     <h3>Outputs</h3>
106 |                     <dl class="message-properties">
107 |         `;
108 | 
109 |         outputs.forEach(output => {
110 |             html += `
111 |                             <dt>${output.name} <span class="property-type">${output.type}</span></dt>
112 |                             <dd>${output.description}</dd>
113 |                     `;
114 |         });
115 | 
116 | 
117 |         html += `
118 |                     </dl>
119 |         `;
120 |     }
121 | 
122 |     html += `
123 |                 </dl>
124 |                 <h3>Details</h3>
125 |                 <p>${details}</p>
126 |                 <h3>Resources</h3>
127 |                 <ul>
128 |     `;
129 | 
130 | 
131 | 
132 |     resources.forEach(resource => {
133 |         html += `
134 |                         <li>
135 |                                 <a href="${resource.link}">${resource.name}</a> - ${resource.description}
136 |                         </li>
137 |                 `;
138 |     });
139 | 
140 |     html += '</ul>';
141 | 
142 |     $(`script[data-help-name="${name}"]`).html(html);
143 | };
144 | 
145 | const generateClientConfig = (config) => {
146 |     let nodeClient = Object.assign({}, config, {
147 |         category: 'particle',
148 |         color: '#C0DEED'
149 |     });
150 | 
151 |     if (config._scopeSelector === true) {
152 |         nodeClient.onScopeChange = function onscopechange() {
153 |             let stream = $('input[name=node-input-scope-options]:checked').val() || 'user';
154 | 
155 |             if (stream === 'product') {
156 |                 $('#particle-scope-product').removeClass('hidden');
157 |             } else {
158 |                 $('#particle-scope-product').addClass('hidden');
159 |                 $('#node-input-product').val('');
160 |             }
161 | 
162 |             $('#node-input-stream').val(stream);
163 |         };
164 | 
165 |         nodeClient.oneditprepare = function oneditprepare() {
166 |             $('input[name=node-input-scope-options]')
167 |                 .prop('checked', null)
168 |                 .change(nodeClient.onScopeChange.bind(this));
169 | 
170 |             const isProduct = $('#node-input-product').val();
171 | 
172 |             if (isProduct) {
173 |                 $('#node-input-scope-product').prop('checked', true);
174 |             } else {
175 |                 $('#node-input-scope-user').prop('checked', true);
176 |             }
177 | 
178 |             nodeClient.onScopeChange();
179 |         };
180 | 
181 |         nodeClient.oneditsave = function oneditsave() {
182 |             nodeClient.onScopeChange();
183 |         };
184 |     }
185 | 
186 |     return nodeClient;
187 | };
188 | 
189 | const addCSS = () => {
190 |     $('body').append(`
191 |         <link rel="stylesheet" href="https://s3.amazonaws.com/icomoon.io/49057/Dashboard/style.css?r41hg3">
192 |         <style>
193 |                 .form-row input[type="radio"] {
194 |                         width: auto !important;
195 |                 }
196 | 
197 |                 .form-row label i.fa {
198 |                         width: 14px;
199 |                 }
200 | 
201 |                 .form-row-radio {
202 |                         padding-top: 9px;
203 |                 }
204 |         </style>
205 |     `);
206 | };
207 | 
208 | const generateNodeFromDefinition = (name, definition) => {
209 |     generateEditTemplate(definition.editTemplate);
210 |     generateDocumentation(definition.documentation);
211 |     addCSS();
212 | 
213 |     RED.nodes.registerType(name, generateClientConfig(definition.client));
214 | };
215 | 
216 | /*global window*/
217 | window.helpers = {
218 |     generateEditTemplate,
219 |     generateDocumentation,
220 |     generateClientConfig,
221 |     generateNodeFromDefinition
222 | };
223 | 
224 | }    
225 | // END helpers.js - This code is automatically updated, do not manually edit!
226 | 
227 | 
228 | const variableEditTemplate = {
229 | 	name: 'particle-variable',
230 | 	fields: [
231 | 		{ name: 'name', icon: 'icon-tag', title: 'Name', placeholder: 'Name', type: 'text' },
232 | 		{ name: 'auth', icon: 'fa fa-user', title: 'Auth', placeholder: 'Auth', type: 'text' },
233 | 		{ name: 'variable', icon: 'im im-speech-bubble-icon', title: 'Variable', placeholder: 'Variable name', type: 'text' },
234 | 		{ name: 'device', icon: 'im im-devices-icon', title: 'Device', placeholder: 'Device name or ID', type: 'text' },
235 | 		{ type: 'scope-selector' }
236 | 	]
237 | };
238 | 
239 | const variableDocumentation = {
240 | 	name: 'particle-variable',
241 | 	title: 'Retrieve a cloud variable from a Particle device',
242 | 	inputs: [
243 | 		{ name: 'variable', type: 'string', description: 'If not configured in node properties, this optional property sets the variable name to retrieve', optional: true },
244 | 		{ name: 'device', type: 'string', description: 'If not configured in node properties, this optional property sets the device name or ID for which to retrieve the variable', optional: true }
245 | 	],
246 | 	outputs: [
247 | 		{ name: 'payload', type: 'string', description: 'The value of the variable retrieved from the device' },
248 | 		{ name: 'variable', type: 'string', description: 'The name of the variable that was retrieved from the device' },
249 | 		{ name: 'device', type: 'string', description: 'The name or ID of the device that was queried' }
250 | 	],
251 | 	details: `
252 | 		<p>Cloud variables allow you to read the value of a sensor or check device state remotely. They are defined in application firmware using <code>Particle.variable()</code>.</p>
253 | 		<p>This node is intended to be placed in the middle of a flow to retrieve a cloud variable from a Particle device.</p>
254 | 		<p>Scope the query to a device either owned by your <b>user</b> account or a device in a <b>product</b> fleet.
255 | 		If querying a device in a product, providing the product slug or ID is required.</p>
256 | 		<p>You may set the variable name to retrieve and the targeted device either as part of node properties, or by passing <code>msg.variable</code> or <code>msg.device</code> as an input to this node, respectively.</p>
257 | 		<p>When the variable value is fetched, it will be appended to to the outbound <code>msg</code> object as <code>msg.payload</code>.
258 | 		The variable name and the device name/ID will also be appended to the outbound <code>msg</code> as <code>msg.variable</code> and <code>msg.device</code>, respectively.</p>
259 | 	`,
260 | 	resources: [
261 | 		{ name: 'Particle.variable() docs', link: 'https://docs.particle.io/reference/firmware/#particle-variable-', description: 'Describes how to define cloud variables in application firmware' }
262 | 	]
263 | };
264 | 
265 | const variableClient = {
266 | 	defaults: {
267 | 		name: { value: '' },
268 | 		auth: { type: 'particle-config', required: true },
269 | 		variable: {},
270 | 		scope: { value: 'user', required: true },
271 | 		device: {},
272 | 		product: {},
273 | 		refresh: {}
274 | 	},
275 | 	inputs: 1,
276 | 	outputs: 1,
277 | 	icon: 'particle.png',
278 | 	align: 'left',
279 | 	paletteLabel: function () {
280 | 		return 'variable';
281 | 	},
282 | 	label: function label() {
283 | 		if (this.name) {
284 | 			return this.name;
285 | 		}
286 | 
287 | 		if (this.variable) {
288 | 			return `variable ${this.variable}`;
289 | 		}
290 | 
291 | 		return variableClient.paletteLabel();
292 | 	},
293 | 	_scopeSelector: true
294 | };
295 | 
296 | /*global window*/
297 | window.variableNodeDefinition = {
298 | 	editTemplate:variableEditTemplate,
299 | 	documentation:variableDocumentation,
300 | 	client:variableClient
301 | };
302 | 
303 | window.helpers.generateNodeFromDefinition('particle-variable', window.variableNodeDefinition);
304 | </script>
305 | 
306 | <script type="text/x-red" data-template-name="particle-variable"></script>
307 | <script type="text/x-red" data-help-name="particle-variable"></script>
308 | 


--------------------------------------------------------------------------------
/nodes/variable/variable.js:
--------------------------------------------------------------------------------
 1 | 'use strict';
 2 | 
 3 | const ParticleBaseNode = require('../../src/particle-base-node');
 4 | 
 5 | module.exports = (RED) => {
 6 | 	function ParticleVariableNode(node) {
 7 | 		RED.nodes.createNode(this, node);
 8 | 
 9 | 		new ParticleBaseNode({
10 | 			self: this,
11 | 			node: node,
12 | 			RED: RED,
13 | 			properties: ['name', 'scope', 'device', 'product', 'variable'],
14 | 			inputProperties: ['device', 'variable'],
15 | 			functionName: 'getVariable',
16 | 			functionArguments: [
17 | 				{ key: 'deviceId', value: 'device' },
18 | 				{ key: 'name', value: 'variable' },
19 | 				{ key: 'product', value: 'product' }
20 | 			],
21 | 			mandatoryArguments: ['deviceId', 'name'],
22 | 			success: {
23 | 				fields: [
24 | 					{ key: 'payload' },
25 | 					{ key: 'variable', value: 'variable' },
26 | 					{ key: 'device', value: 'device' }
27 | 				],
28 | 				status: 'fetched'
29 | 			},
30 | 			info: {
31 | 				status: 'fetching'
32 | 			},
33 | 			error: {
34 | 				status: 'failed',
35 | 				onRuntime: 'Failed to fetch varaible'
36 | 			}
37 | 		});
38 | 	}
39 | 
40 | 	RED.nodes.registerType('particle-variable', ParticleVariableNode);
41 | 
42 | 
43 | };
44 | 


--------------------------------------------------------------------------------
/package-lock.json:
--------------------------------------------------------------------------------
  1 | {
  2 |   "name": "@particle/node-red-contrib-particle-official",
  3 |   "version": "0.1.6",
  4 |   "lockfileVersion": 1,
  5 |   "requires": true,
  6 |   "dependencies": {
  7 |     "asynckit": {
  8 |       "version": "0.4.0",
  9 |       "resolved": "https://registry.npmjs.org/asynckit/-/asynckit-0.4.0.tgz",
 10 |       "integrity": "sha1-x57Zf380y48robyXkLzDZkdLS3k="
 11 |     },
 12 |     "babel-runtime": {
 13 |       "version": "6.26.0",
 14 |       "resolved": "https://registry.npmjs.org/babel-runtime/-/babel-runtime-6.26.0.tgz",
 15 |       "integrity": "sha1-llxwWGaOgrVde/4E/yM3vItWR/4=",
 16 |       "requires": {
 17 |         "core-js": "^2.4.0",
 18 |         "regenerator-runtime": "^0.11.0"
 19 |       }
 20 |     },
 21 |     "builtin-status-codes": {
 22 |       "version": "2.0.0",
 23 |       "resolved": "https://registry.npmjs.org/builtin-status-codes/-/builtin-status-codes-2.0.0.tgz",
 24 |       "integrity": "sha1-byIAO6rPADzNKHr+aHIVH93FhXk="
 25 |     },
 26 |     "combined-stream": {
 27 |       "version": "1.0.8",
 28 |       "resolved": "https://registry.npmjs.org/combined-stream/-/combined-stream-1.0.8.tgz",
 29 |       "integrity": "sha512-FQN4MRfuJeHf7cBbBMJFXhKSDq+2kAArBlmRBvcvFE5BB1HZKXtSFASDhdlz9zOYwxh8lDdnvmMOe/+5cdoEdg==",
 30 |       "requires": {
 31 |         "delayed-stream": "~1.0.0"
 32 |       }
 33 |     },
 34 |     "component-emitter": {
 35 |       "version": "1.3.0",
 36 |       "resolved": "https://registry.npmjs.org/component-emitter/-/component-emitter-1.3.0.tgz",
 37 |       "integrity": "sha512-Rd3se6QB+sO1TwqZjscQrurpEPIfO0/yYnSin6Q/rD3mOutHvUrCAhJub3r90uNb+SESBuE0QYoB90YdfatsRg=="
 38 |     },
 39 |     "cookiejar": {
 40 |       "version": "2.1.2",
 41 |       "resolved": "https://registry.npmjs.org/cookiejar/-/cookiejar-2.1.2.tgz",
 42 |       "integrity": "sha512-Mw+adcfzPxcPeI+0WlvRrr/3lGVO0bD75SxX6811cxSh1Wbxx7xZBGK1eVtDf6si8rg2lhnUjsVLMFMfbRIuwA=="
 43 |     },
 44 |     "core-js": {
 45 |       "version": "2.6.11",
 46 |       "resolved": "https://registry.npmjs.org/core-js/-/core-js-2.6.11.tgz",
 47 |       "integrity": "sha512-5wjnpaT/3dV+XB4borEsnAYQchn00XSgTAWKDkEqv+K8KevjbzmofK6hfJ9TZIlpj2N0xQpazy7PiRQiWHqzWg=="
 48 |     },
 49 |     "debug": {
 50 |       "version": "4.1.1",
 51 |       "resolved": "https://registry.npmjs.org/debug/-/debug-4.1.1.tgz",
 52 |       "integrity": "sha512-pYAIzeRo8J6KPEaJ0VWOh5Pzkbw/RetuzehGM7QRRX5he4fPHx2rdKMB256ehJCkX+XRQm16eZLqLNS8RSZXZw==",
 53 |       "requires": {
 54 |         "ms": "^2.1.1"
 55 |       }
 56 |     },
 57 |     "delayed-stream": {
 58 |       "version": "1.0.0",
 59 |       "resolved": "https://registry.npmjs.org/delayed-stream/-/delayed-stream-1.0.0.tgz",
 60 |       "integrity": "sha1-3zrhmayt+31ECqrgsp4icrJOxhk="
 61 |     },
 62 |     "fast-safe-stringify": {
 63 |       "version": "2.0.7",
 64 |       "resolved": "https://registry.npmjs.org/fast-safe-stringify/-/fast-safe-stringify-2.0.7.tgz",
 65 |       "integrity": "sha512-Utm6CdzT+6xsDk2m8S6uL8VHxNwI6Jub+e9NYTcAms28T84pTa25GJQV9j0CY0N1rM8hK4x6grpF2BQf+2qwVA=="
 66 |     },
 67 |     "form-data": {
 68 |       "version": "3.0.0",
 69 |       "resolved": "https://registry.npmjs.org/form-data/-/form-data-3.0.0.tgz",
 70 |       "integrity": "sha512-CKMFDglpbMi6PyN+brwB9Q/GOw0eAnsrEZDgcsH5Krhz5Od/haKHAX0NmQfha2zPPz0JpWzA7GJHGSnvCRLWsg==",
 71 |       "requires": {
 72 |         "asynckit": "^0.4.0",
 73 |         "combined-stream": "^1.0.8",
 74 |         "mime-types": "^2.1.12"
 75 |       }
 76 |     },
 77 |     "formidable": {
 78 |       "version": "1.2.2",
 79 |       "resolved": "https://registry.npmjs.org/formidable/-/formidable-1.2.2.tgz",
 80 |       "integrity": "sha512-V8gLm+41I/8kguQ4/o1D3RIHRmhYFG4pnNyonvua+40rqcEmT4+V71yaZ3B457xbbgCsCfjSPi65u/W6vK1U5Q=="
 81 |     },
 82 |     "inherits": {
 83 |       "version": "2.0.4",
 84 |       "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz",
 85 |       "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ=="
 86 |     },
 87 |     "lodash": {
 88 |       "version": "4.17.21",
 89 |       "resolved": "https://registry.npmjs.org/lodash/-/lodash-4.17.21.tgz",
 90 |       "integrity": "sha512-v2kDEe57lecTulaDIuNTPy3Ry4gLGJ6Z1O3vE1krgXZNrsQ+LFTGHVxVjcXPs17LhbZVGedAJv8XZ1tvj5FvSg=="
 91 |     },
 92 |     "methods": {
 93 |       "version": "1.1.2",
 94 |       "resolved": "https://registry.npmjs.org/methods/-/methods-1.1.2.tgz",
 95 |       "integrity": "sha1-VSmk1nZUE07cxSZmVoNbD4Ua/O4="
 96 |     },
 97 |     "mime": {
 98 |       "version": "2.4.6",
 99 |       "resolved": "https://registry.npmjs.org/mime/-/mime-2.4.6.tgz",
100 |       "integrity": "sha512-RZKhC3EmpBchfTGBVb8fb+RL2cWyw/32lshnsETttkBAyAUXSGHxbEJWWRXc751DrIxG1q04b8QwMbAwkRPpUA=="
101 |     },
102 |     "mime-db": {
103 |       "version": "1.44.0",
104 |       "resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.44.0.tgz",
105 |       "integrity": "sha512-/NOTfLrsPBVeH7YtFPgsVWveuL+4SjjYxaQ1xtM1KMFj7HdxlBlxeyNLzhyJVx7r4rZGJAZ/6lkKCitSc/Nmpg=="
106 |     },
107 |     "mime-types": {
108 |       "version": "2.1.27",
109 |       "resolved": "https://registry.npmjs.org/mime-types/-/mime-types-2.1.27.tgz",
110 |       "integrity": "sha512-JIhqnCasI9yD+SsmkquHBxTSEuZdQX5BuQnS2Vc7puQQQ+8yiP5AY5uWhpdv4YL4VM5c6iliiYWPgJ/nJQLp7w==",
111 |       "requires": {
112 |         "mime-db": "1.44.0"
113 |       }
114 |     },
115 |     "ms": {
116 |       "version": "2.1.2",
117 |       "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.2.tgz",
118 |       "integrity": "sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w=="
119 |     },
120 |     "particle-api-js": {
121 |       "version": "9.0.2",
122 |       "resolved": "https://registry.npmjs.org/particle-api-js/-/particle-api-js-9.0.2.tgz",
123 |       "integrity": "sha512-w+KG6ybdwFKJCiTZ6sQMAFX5FJS16cA5JyG4o8th80ULneTI9WYfj9Twa0WHdC598inF+rYJRouqHS47/VWqOA==",
124 |       "requires": {
125 |         "babel-runtime": "^6.9.2",
126 |         "form-data": ">2.2.0",
127 |         "stream-http": "https://github.com/particle-iot/stream-http/archive/v2.2.1.tar.gz",
128 |         "superagent": "^5.1.2",
129 |         "superagent-prefix": "0.0.2"
130 |       }
131 |     },
132 |     "qs": {
133 |       "version": "6.9.4",
134 |       "resolved": "https://registry.npmjs.org/qs/-/qs-6.9.4.tgz",
135 |       "integrity": "sha512-A1kFqHekCTM7cz0udomYUoYNWjBebHm/5wzU/XqrBRBNWectVH0QIiN+NEcZ0Dte5hvzHwbr8+XQmguPhJ6WdQ=="
136 |     },
137 |     "readable-stream": {
138 |       "version": "3.6.0",
139 |       "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-3.6.0.tgz",
140 |       "integrity": "sha512-BViHy7LKeTz4oNnkcLJ+lVSL6vpiFeX6/d3oSH8zCW7UxP2onchk+vTGB143xuFjHS3deTgkKoXXymXqymiIdA==",
141 |       "requires": {
142 |         "inherits": "^2.0.3",
143 |         "string_decoder": "^1.1.1",
144 |         "util-deprecate": "^1.0.1"
145 |       }
146 |     },
147 |     "regenerator-runtime": {
148 |       "version": "0.11.1",
149 |       "resolved": "https://registry.npmjs.org/regenerator-runtime/-/regenerator-runtime-0.11.1.tgz",
150 |       "integrity": "sha512-MguG95oij0fC3QV3URf4V2SDYGJhJnJGqvIIgdECeODCT98wSWDAJ94SSuVpYQUoTcGUIL6L4yNB7j1DFFHSBg=="
151 |     },
152 |     "safe-buffer": {
153 |       "version": "5.2.1",
154 |       "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.2.1.tgz",
155 |       "integrity": "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ=="
156 |     },
157 |     "semver": {
158 |       "version": "7.3.2",
159 |       "resolved": "https://registry.npmjs.org/semver/-/semver-7.3.2.tgz",
160 |       "integrity": "sha512-OrOb32TeeambH6UrhtShmF7CRDqhL6/5XpPNp2DuRH6+9QLw/orhp72j87v8Qa1ScDkvrrBNpZcDejAirJmfXQ=="
161 |     },
162 |     "stream-http": {
163 |       "version": "https://github.com/particle-iot/stream-http/archive/v2.2.1.tar.gz",
164 |       "integrity": "sha512-eiMmV7ssQY13N4JoAHkr9nWvq5TgbQp6VyeCA6/UGZjBSepFMhtfICRDNzkzPNY/NPJ/os0an1xExHISjfBkmg==",
165 |       "requires": {
166 |         "builtin-status-codes": "^2.0.0",
167 |         "inherits": "^2.0.1",
168 |         "to-arraybuffer": "^1.0.0",
169 |         "xtend": "^4.0.0"
170 |       }
171 |     },
172 |     "string_decoder": {
173 |       "version": "1.3.0",
174 |       "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.3.0.tgz",
175 |       "integrity": "sha512-hkRX8U1WjJFd8LsDJ2yQ/wWWxaopEsABU1XfkM8A+j0+85JAGppt16cr1Whg6KIbb4okU6Mql6BOj+uup/wKeA==",
176 |       "requires": {
177 |         "safe-buffer": "~5.2.0"
178 |       }
179 |     },
180 |     "superagent": {
181 |       "version": "5.3.1",
182 |       "resolved": "https://registry.npmjs.org/superagent/-/superagent-5.3.1.tgz",
183 |       "integrity": "sha512-wjJ/MoTid2/RuGCOFtlacyGNxN9QLMgcpYLDQlWFIhhdJ93kNscFonGvrpAHSCVjRVj++DGCglocF7Aej1KHvQ==",
184 |       "requires": {
185 |         "component-emitter": "^1.3.0",
186 |         "cookiejar": "^2.1.2",
187 |         "debug": "^4.1.1",
188 |         "fast-safe-stringify": "^2.0.7",
189 |         "form-data": "^3.0.0",
190 |         "formidable": "^1.2.2",
191 |         "methods": "^1.1.2",
192 |         "mime": "^2.4.6",
193 |         "qs": "^6.9.4",
194 |         "readable-stream": "^3.6.0",
195 |         "semver": "^7.3.2"
196 |       }
197 |     },
198 |     "superagent-prefix": {
199 |       "version": "0.0.2",
200 |       "resolved": "https://registry.npmjs.org/superagent-prefix/-/superagent-prefix-0.0.2.tgz",
201 |       "integrity": "sha1-sVu7E1P4ibANJa8QtPEbNQ0gOwY="
202 |     },
203 |     "to-arraybuffer": {
204 |       "version": "1.0.1",
205 |       "resolved": "https://registry.npmjs.org/to-arraybuffer/-/to-arraybuffer-1.0.1.tgz",
206 |       "integrity": "sha1-fSKbH8xjfkZsoIEYCDanqr/4P0M="
207 |     },
208 |     "util-deprecate": {
209 |       "version": "1.0.2",
210 |       "resolved": "https://registry.npmjs.org/util-deprecate/-/util-deprecate-1.0.2.tgz",
211 |       "integrity": "sha1-RQ1Nyfpw3nMnYvvS1KKJgUGaDM8="
212 |     },
213 |     "xtend": {
214 |       "version": "4.0.2",
215 |       "resolved": "https://registry.npmjs.org/xtend/-/xtend-4.0.2.tgz",
216 |       "integrity": "sha512-LKYU1iAXJXUgAXn9URjiu+MWhyUXHsvfp7mcuYm9dSUKK0/CjtrUwFAxD82/mCWbtLsGjFIad0wIsod4zrTAEQ=="
217 |     }
218 |   }
219 | }
220 | 


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "@particle/node-red-contrib-particle-official",
 3 |   "version": "0.1.7",
 4 |   "description": "Official Node-RED Particle nodes",
 5 |   "scripts": {},
 6 |   "repository": {
 7 |     "type": "git",
 8 |     "url": "https://github.com/particle-iot/node-red-contrib-particle-official.git"
 9 |   },
10 |   "keywords": [
11 |     "node-red"
12 |   ],
13 |   "node-red": {
14 |     "nodes": {
15 |       "config": "nodes/config/config.js",
16 |       "publish": "nodes/publish/publish.js",
17 |       "subscribe": "nodes/subscribe/subscribe.js",
18 |       "variable": "nodes/variable/variable.js",
19 |       "function": "nodes/function/function.js",
20 |       "api": "nodes/api/api.js"
21 |     }
22 |   },
23 |   "author": "Wojtek 'suda' Siudzinski",
24 |   "license": "MIT",
25 |   "bugs": {
26 |     "url": "https://github.com/particle-iot/node-red-contrib-particle-official/issues"
27 |   },
28 |   "homepage": "https://github.com/particle-iot/node-red-contrib-particle-official#readme",
29 |   "dependencies": {
30 |     "lodash": "^4.17.21",
31 |     "particle-api-js": "^9.0.2"
32 |   }
33 | }
34 | 


--------------------------------------------------------------------------------
/src/api.js:
--------------------------------------------------------------------------------
  1 | 'use strict';
  2 | 
  3 | const Particle = require('particle-api-js');
  4 | 
  5 | module.exports = class Api {
  6 | 	/**
  7 | 	 * API wrapper constructor
  8 | 	 *
  9 | 	 * @param {ParticleConfigNode} auth
 10 | 	 * @param {Console} logger
 11 | 	 */
 12 | 	constructor(auth, logger=console) {
 13 | 		this._auth = auth;
 14 | 		this._logger = logger;
 15 | 		this._defaultExpiresIn = 2147483647;
 16 | 		this._init();
 17 | 	}
 18 | 
 19 | 	/**
 20 | 	 * Login using the client credentials, store the access token
 21 | 	 * and set up token refresh before it expires
 22 | 	 *
 23 | 	 * @returns {Promise} Login promise
 24 | 	 */
 25 | 	login() {
 26 | 		return this._particle.loginAsClientOwner({}).then((res) => {
 27 | 			this._logger.log('Authenticated with Particle');
 28 | 			this._accessToken = res.body.access_token;
 29 | 			// Reauthenticate before the token expires
 30 | 			// There is res.body.expires_in property but
 31 | 			// as setTimeout is using 32 bit int the maximum
 32 | 			// we can set is 2147483647 (~24 days)
 33 | 			const expiresIn = Math.min(this._defaultExpiresIn, res.body.expires_in);
 34 | 			this._expirationTimer = setTimeout(
 35 | 				this._reauthenticate.bind(this),
 36 | 				expiresIn
 37 | 			);
 38 | 
 39 | 			return this._accessToken;
 40 | 		});
 41 | 	}
 42 | 
 43 | 	/**
 44 | 	 * Get the EventStream and subscribe to the 'event' event
 45 | 	 * with onEvent callback
 46 | 	 *
 47 | 	 * @param {Function} onEvent
 48 | 	 * @param {String} options.deviceId
 49 | 	 * @param {String} options.name
 50 | 	 * @param {String} options.product
 51 | 	 * @returns {Promise} Resolves when adding listener succeeded
 52 | 	 */
 53 | 	listenToEventStream({ onEvent, deviceId, name, product }) {
 54 | 		this._lastListenArguments = arguments;
 55 | 		return this._particle.getEventStream({
 56 | 			deviceId, name, product, auth: this._accessToken
 57 | 		}).then((stream) => {
 58 | 			this._stream = stream;
 59 | 			this._stream.on('event', onEvent);
 60 | 			this._stream.on('error', this._reauthenticate.bind(this));
 61 | 			this._stream.on('end', this._reauthenticate.bind(this));
 62 | 		});
 63 | 	}
 64 | 
 65 | 	/**
 66 | 	 * Publish a Particle event
 67 | 	 *
 68 | 	 * @param {Object} params Event params
 69 | 	 * @param {String} params.name Event name
 70 | 	 * @param {String} params.data Event data
 71 | 	 * @param {String} params.product Event for this product ID or slug
 72 | 	 * @param {Boolean} params.isPrivate Should the event be publicly available?
 73 | 	 * @returns {Promise} Resolves when event has been published
 74 | 	 */
 75 | 	publishEvent(params) {
 76 | 		return this._particle.publishEvent(Object.assign({
 77 | 			auth: this._accessToken
 78 | 		}, params));
 79 | 	}
 80 | 
 81 | 	/**
 82 | 	 * Get the value of a device variable
 83 | 	 * @param  {Object} params Options for this API call
 84 | 	 * @param  {String} params.deviceId Device ID or Name
 85 | 	 * @param  {String} params.name     Variable name
 86 | 	 * @param  {String} [params.product] Device in this product ID or slug
 87 | 	 * @param  {String} params.auth     Access Token
 88 | 	 * @return {Promise} Resolves when the variable was fetched
 89 | 	 */
 90 | 	getVariable(params) {
 91 | 		return this._particle.getVariable(Object.assign({
 92 | 			auth: this._accessToken
 93 | 		}, params))
 94 | 			.then(response => {
 95 | 				return response.body.result;
 96 | 			}, (error) => {
 97 | 				throw error;
 98 | 			});
 99 | 	}
100 | 
101 | 	/**
102 | 	 * Call a device function
103 | 	 * @param  {Object} options Options for this API call
104 | 	 * @param  {String} options.deviceId Device ID or Name
105 | 	 * @param  {String} options.name     Function name
106 | 	 * @param  {String} options.argument Function argument
107 | 	 * @param  {String} [options.product] Device in this product ID or slug
108 | 	 * @param  {String} options.auth     Access Token
109 | 	 * @return {Promise} Resolves when the function was called
110 | 	 */
111 | 	callFunction(options) {
112 | 		return this._particle.callFunction(Object.assign({
113 | 			auth: this._accessToken
114 | 		}, options))
115 | 			.then(response => {
116 | 				return response.body.return_value;
117 | 			}, (error) => {
118 | 				throw error;
119 | 			});
120 | 	}
121 | 
122 | 	request(params) {
123 | 		return this._particle.request(Object.assign({
124 | 			auth: this._accessToken
125 | 		}, params));
126 | 	}
127 | 
128 | 	/**
129 | 	 * Close the stream, remove all timers, listeners etc.
130 | 	 */
131 | 	cleanup() {
132 | 		clearTimeout(this._expirationTimer);
133 | 
134 | 		if (this._stream) {
135 | 			this._stream.abort();
136 | 		}
137 | 
138 | 		this._particle.deleteCurrentAccessToken({
139 | 			auth: this._accessToken
140 | 		});
141 | 	}
142 | 
143 | 	/**
144 | 	 * Instantiate Particle and set the config
145 | 	 *
146 | 	 * @private
147 | 	 */
148 | 	_init() {
149 | 		this._particle = new Particle({
150 | 			clientId: this._auth.clientId,
151 | 			clientSecret: this._auth.clientSecret
152 | 		});
153 | 		this._particle.setContext('tool', {
154 | 			name: 'node-red-contrib-particle'
155 | 		});
156 | 	}
157 | 
158 | 	/**
159 | 	 * Callback that fetches a new token and recreates all
160 | 	 * event callbacks to prevent data loss.
161 | 	 *
162 | 	 * @private
163 | 	 */
164 | 	_reauthenticate() {
165 | 		this._logger.log('Reauthenticating...');
166 | 		this.cleanup();
167 | 
168 | 		this.login().then(() => {
169 | 			this.listenToEventStream.apply(this, this._lastListenArguments);
170 | 		}, () => {
171 | 			const retryIn = 5;
172 | 			this._logger.error(`Failed to reauthenticate. Trying again in ${retryIn} seconds`);
173 | 			setTimeout(this._reauthenticate.bind(this), retryIn * 1000);
174 | 		});
175 | 	}
176 | };
177 | 


--------------------------------------------------------------------------------
/src/helpers.js:
--------------------------------------------------------------------------------
 1 | 'use strict';
 2 | 
 3 | const resetStatus = ({ status, timeout = 0 }) => {
 4 | 	setTimeout(() => {
 5 | 		status({});
 6 | 	}, timeout);
 7 | };
 8 | 
 9 | const onSuccess = ({ status, message }) => {
10 | 	status({ fill: 'green', shape: 'dot', text: message });
11 | 
12 | 	resetStatus({
13 | 		status,
14 | 		timeout: 1000
15 | 	});
16 | };
17 | 
18 | const onInfo = ({ status, message }) => {
19 | 	status({ fill: 'blue', shape: 'dot', text: message });
20 | };
21 | 
22 | const onError = ({ status, message }) => {
23 | 	status({ fill: 'red', shape: 'ring', text: message });
24 | };
25 | 
26 | module.exports = {
27 | 	onSuccess,
28 | 	onInfo,
29 | 	onError,
30 | 	resetStatus
31 | };
32 | 


--------------------------------------------------------------------------------
/src/particle-base-node.js:
--------------------------------------------------------------------------------
  1 | 'use strict';
  2 | 
  3 | const Api = require('./api');
  4 | const _ = require('lodash');
  5 | const helpers = require('./helpers');
  6 | 
  7 | class ParticleBaseNode {
  8 | 	constructor({ self, node, RED, properties, functionName, functionArguments, mandatoryArguments, onAPIResponse, onAPIError, inputProperties, runOnLoad, success, error, info }) {
  9 | 		this.self = self;
 10 | 		this.node = node;
 11 | 		this.RED = RED;
 12 | 		this.message = null;
 13 | 		this.variables = {};
 14 | 		this.functionName = functionName;
 15 | 		this.functionArguments = functionArguments;
 16 | 		this.mandatoryArguments = mandatoryArguments;
 17 | 		this.inputProperties = inputProperties;
 18 | 		this.onAPIResponse = onAPIResponse;
 19 | 		this.onAPIError = onAPIError;
 20 | 		this.runOnLoad = runOnLoad || node.runOnLoad;
 21 | 		this.success = success || node.success;
 22 | 		this.error = error;
 23 | 		this.info = info || {};
 24 | 
 25 | 		properties.forEach(field => {
 26 | 			this.variables[field] = node[field];
 27 | 		});
 28 | 
 29 | 		this.auth = this.RED.nodes.getNode(node.auth);
 30 | 
 31 | 		if (this.auth) {
 32 | 			this.api = new Api(this.auth);
 33 | 		} else if (node.testAuth) {
 34 | 			this.api = new Api(node.testAuth);
 35 | 		}
 36 | 
 37 | 		this.run();
 38 | 	}
 39 | 
 40 | 	hasMandatoryArguments(args = [], params = {}) {
 41 | 		let ok = true;
 42 | 
 43 | 		args.forEach(arg => {
 44 | 			if (!params[arg]) {
 45 | 				ok = false;
 46 | 
 47 | 				this.self.error(`Missing the ${arg} parameter`);
 48 | 			}
 49 | 		});
 50 | 
 51 | 		return ok;
 52 | 	}
 53 | 
 54 | 	parametersFromVariables(variables, functionArguments) {
 55 | 		let params = {};
 56 | 		let ok = true;
 57 | 
 58 | 		functionArguments.forEach(argument => {
 59 | 			let value = null;
 60 | 
 61 | 			if (argument.defaultValue) {
 62 | 				value = argument.defaultValue;
 63 | 			}
 64 | 
 65 | 			if (argument.value && variables[argument.value]) {
 66 | 				value = variables[argument.value];
 67 | 			}
 68 | 
 69 | 			if (argument.customValue) {
 70 | 				value = argument.customValue(variables);
 71 | 			}
 72 | 
 73 | 			if (argument.format === 'object' && typeof value !== 'object') {
 74 | 				try {
 75 | 					value = JSON.parse(value);
 76 | 
 77 | 					if (typeof value !== 'object') {
 78 | 						throw 'Argument not a valid JSON object';
 79 | 					}
 80 | 				} catch (e) {
 81 | 					if (this.error.onConfig) {
 82 | 						this.self.error(this.error.onConfig);
 83 | 					}
 84 | 
 85 | 					ok = false;
 86 | 				}
 87 | 			}
 88 | 
 89 | 			if (argument.prefix && value) {
 90 | 				value = `${argument.prefix}${value}`;
 91 | 			}
 92 | 
 93 | 			params[argument.key] = value;
 94 | 		});
 95 | 
 96 | 		return ok ? params : null;
 97 | 	}
 98 | 
 99 | 	successStatus(message = 'OK') {
100 | 		return helpers.onSuccess({ status: this.self.status.bind(this.self), message });
101 | 	}
102 | 
103 | 	errorStatus(message = 'NOT OK') {
104 | 		return helpers.onError({ status: this.self.status.bind(this.self), message });
105 | 	}
106 | 
107 | 	infoStatus(message = 'processing') {
108 | 		return helpers.onInfo({ status: this.self.status.bind(this.self), message });
109 | 	}
110 | 
111 | 	hideStatus() {
112 | 		return helpers.resetStatus({ status: this.self.status.bind(this.self), timeout: 0 });
113 | 	}
114 | 
115 | 	makeAPIRequest(variables) {
116 | 		const parameters = this.parametersFromVariables(variables, this.functionArguments);
117 | 
118 | 		if (!parameters) {
119 | 			return null;
120 | 		}
121 | 
122 | 		const hasMandatoryArguments = this.hasMandatoryArguments(this.mandatoryArguments, parameters);
123 | 
124 | 		if (!hasMandatoryArguments) {
125 | 			return null;
126 | 		}
127 | 
128 | 		this.infoStatus(this.info.status);
129 | 
130 | 		this.api[this.functionName](parameters)
131 | 			.then(result => {
132 | 				this.hideStatus();
133 | 
134 | 				if (this.success && this.success.status) {
135 | 					this.successStatus(this.success.status);
136 | 				}
137 | 
138 | 				if (this.onAPIResponse) {
139 | 					return this.onAPIResponse(variables, this.message, result);
140 | 				} else if (this.success && this.success.fields) {
141 | 					const fields = this.success.fields;
142 | 					let message = this.message || {};
143 | 
144 | 					fields.forEach(field => {
145 | 						if (field.path) {
146 | 							message[field.key] = _.get(result, field.path);
147 | 						} else if (field.value) {
148 | 							message[field.key] = variables[field.value];
149 | 						} else if (field.key === 'payload') {
150 | 							message.payload = result;
151 | 						}
152 | 					});
153 | 
154 | 					return this.self.send(message);
155 | 				} else {
156 | 					return true;
157 | 				}
158 | 			}, (error) => {
159 | 				this.hideStatus();
160 | 
161 | 				if (this.error && this.error.status) {
162 | 					this.errorStatus(this.error.status);
163 | 				}
164 | 
165 | 				if (this.onAPIError) {
166 | 					return this.onAPIError(error);
167 | 				}
168 | 
169 | 				if (this.error && this.error.onRuntime) {
170 | 					this.self.error(`${this.error.onRuntime} (${error})`, this.message || {});
171 | 				}
172 | 
173 | 				return false;
174 | 			});
175 | 	}
176 | 
177 | 	onClose() {
178 | 		this.api.cleanup();
179 | 	}
180 | 
181 | 	mergePropertiesFromMsg(variables, inputProperties, msg) {
182 | 		let _var = Object.assign({}, variables);
183 | 		const data = msg;
184 | 
185 | 		if (data) {
186 | 			inputProperties.forEach(field => {
187 | 				if (data[field] && !_var[field]) {
188 | 					_var[field] = data[field];
189 | 				}
190 | 			});
191 | 		}
192 | 
193 | 		return _var;
194 | 	}
195 | 
196 | 	onInput(msg) {
197 | 		if (msg) {
198 | 			this.message = msg;
199 | 		}
200 | 
201 | 		let variables = this.mergePropertiesFromMsg(this.variables, this.inputProperties, msg);
202 | 
203 | 		this.makeAPIRequest(variables);
204 | 	}
205 | 
206 | 	run() {
207 | 		if (!this.api) {
208 | 			return null;
209 | 		}
210 | 
211 | 		this.api.login()
212 | 			.then(() => {
213 | 				this.self.on('input', this.onInput.bind(this));
214 | 				this.self.on('close', this.onClose.bind(this));
215 | 
216 | 				if (this.runOnLoad) {
217 | 					this.makeAPIRequest(this.variables);
218 | 				}
219 | 			});
220 | 	}
221 | }
222 | 
223 | module.exports = ParticleBaseNode;
224 | 


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