1 | # Licensed to the StackStorm, Inc ('StackStorm') under one or more |
||
2 | # contributor license agreements. See the NOTICE file distributed with |
||
3 | # this work for additional information regarding copyright ownership. |
||
4 | # The ASF licenses this file to You under the Apache License, Version 2.0 |
||
5 | # (the "License"); you may not use this file except in compliance with |
||
6 | # the License. You may obtain a copy of the License at |
||
7 | # |
||
8 | # http://www.apache.org/licenses/LICENSE-2.0 |
||
9 | # |
||
10 | # Unless required by applicable law or agreed to in writing, software |
||
11 | # distributed under the License is distributed on an "AS IS" BASIS, |
||
12 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
||
13 | # See the License for the specific language governing permissions and |
||
14 | # limitations under the License. |
||
15 | |||
16 | from __future__ import absolute_import |
||
17 | import copy |
||
18 | |||
19 | from st2common.util import isotime |
||
20 | from st2common.util import schema as util_schema |
||
21 | from st2common import log as logging |
||
22 | from st2common.constants.pack import DEFAULT_PACK_NAME |
||
23 | from st2common.models.api.base import BaseAPI |
||
24 | from st2common.models.api.base import APIUIDMixin |
||
25 | from st2common.models.api.tag import TagsHelper |
||
26 | from st2common.models.api.notification import (NotificationSubSchemaAPI, NotificationsHelper) |
||
27 | from st2common.models.db.action import ActionDB |
||
28 | from st2common.models.db.actionalias import ActionAliasDB |
||
29 | from st2common.models.db.executionstate import ActionExecutionStateDB |
||
30 | from st2common.models.db.liveaction import LiveActionDB |
||
31 | from st2common.models.db.runner import RunnerTypeDB |
||
32 | from st2common.constants.action import LIVEACTION_STATUSES |
||
33 | from st2common.models.system.common import ResourceReference |
||
34 | |||
35 | |||
36 | __all__ = [ |
||
37 | 'ActionAPI', |
||
38 | 'ActionCreateAPI', |
||
39 | 'LiveActionAPI', |
||
40 | 'LiveActionCreateAPI', |
||
41 | 'RunnerTypeAPI', |
||
42 | |||
43 | 'AliasExecutionAPI', |
||
44 | 'AliasMatchAndExecuteInputAPI', |
||
45 | 'ActionAliasAPI', |
||
46 | 'ActionAliasMatchAPI', |
||
47 | 'ActionAliasHelpAPI' |
||
48 | ] |
||
49 | |||
50 | |||
51 | LOG = logging.getLogger(__name__) |
||
52 | |||
53 | |||
54 | class RunnerTypeAPI(BaseAPI): |
||
55 | """ |
||
56 | The representation of an RunnerType in the system. An RunnerType |
||
57 | has a one-to-one mapping to a particular ActionRunner implementation. |
||
58 | """ |
||
59 | model = RunnerTypeDB |
||
60 | schema = { |
||
61 | "title": "Runner", |
||
62 | "description": "A handler for a specific type of actions.", |
||
63 | "type": "object", |
||
64 | "properties": { |
||
65 | "id": { |
||
66 | "description": "The unique identifier for the action runner.", |
||
67 | "type": "string", |
||
68 | "default": None |
||
69 | }, |
||
70 | "uid": { |
||
71 | "type": "string" |
||
72 | }, |
||
73 | "name": { |
||
74 | "description": "The name of the action runner.", |
||
75 | "type": "string", |
||
76 | "required": True |
||
77 | }, |
||
78 | "description": { |
||
79 | "description": "The description of the action runner.", |
||
80 | "type": "string" |
||
81 | }, |
||
82 | "enabled": { |
||
83 | "description": "Enable or disable the action runner.", |
||
84 | "type": "boolean", |
||
85 | "default": True |
||
86 | }, |
||
87 | "runner_package": { |
||
88 | "description": "The python package that implements the " |
||
89 | "action runner for this type.", |
||
90 | "type": "string", |
||
91 | "required": False |
||
92 | }, |
||
93 | "runner_module": { |
||
94 | "description": "The python module that implements the " |
||
95 | "action runner for this type.", |
||
96 | "type": "string", |
||
97 | "required": True |
||
98 | }, |
||
99 | "query_module": { |
||
100 | "description": "The python module that implements the " |
||
101 | "results tracker (querier) for the runner.", |
||
102 | "type": "string", |
||
103 | "required": False |
||
104 | }, |
||
105 | "runner_parameters": { |
||
106 | "description": "Input parameters for the action runner.", |
||
107 | "type": "object", |
||
108 | "patternProperties": { |
||
109 | "^\w+$": util_schema.get_action_parameters_schema() |
||
110 | }, |
||
111 | 'additionalProperties': False |
||
112 | } |
||
113 | }, |
||
114 | "additionalProperties": False |
||
115 | } |
||
116 | |||
117 | def __init__(self, **kw): |
||
0 ignored issues
–
show
|
|||
118 | # Ideally, you should not do that. You should not redefine __init__ to validate and then set |
||
119 | # default values, instead you should define defaults in schema and use BaseAPI __init__ |
||
120 | # validator to unwrap them. The problem here is that draft schema also contains default |
||
121 | # values and we don't want them to be unwrapped at the same time. I've tried to remove the |
||
122 | # default values from draft schema, but, either because of a bug or some weird intention, it |
||
123 | # has continued to resolve $ref'erenced properties against the initial draft schema, not the |
||
124 | # modified one |
||
125 | for key, value in kw.items(): |
||
126 | setattr(self, key, value) |
||
127 | if not hasattr(self, 'runner_parameters'): |
||
128 | setattr(self, 'runner_parameters', dict()) |
||
129 | |||
130 | @classmethod |
||
131 | def to_model(cls, runner_type): |
||
132 | name = runner_type.name |
||
133 | description = runner_type.description |
||
134 | enabled = getattr(runner_type, 'enabled', True) |
||
135 | runner_package = getattr(runner_type, 'runner_package', runner_type.runner_module) |
||
136 | runner_module = str(runner_type.runner_module) |
||
137 | runner_parameters = getattr(runner_type, 'runner_parameters', dict()) |
||
138 | query_module = getattr(runner_type, 'query_module', None) |
||
139 | |||
140 | model = cls.model(name=name, description=description, enabled=enabled, |
||
141 | runner_package=runner_package, runner_module=runner_module, |
||
142 | runner_parameters=runner_parameters, |
||
143 | query_module=query_module) |
||
144 | |||
145 | return model |
||
146 | |||
147 | |||
148 | class ActionAPI(BaseAPI, APIUIDMixin): |
||
149 | """ |
||
150 | The system entity that represents a Stack Action/Automation in the system. |
||
151 | """ |
||
152 | |||
153 | model = ActionDB |
||
154 | schema = { |
||
155 | "title": "Action", |
||
156 | "description": "An activity that happens as a response to the external event.", |
||
157 | "type": "object", |
||
158 | "properties": { |
||
159 | "id": { |
||
160 | "description": "The unique identifier for the action.", |
||
161 | "type": "string" |
||
162 | }, |
||
163 | "ref": { |
||
164 | "description": "System computed user friendly reference for the action. \ |
||
165 | Provided value will be overridden by computed value.", |
||
166 | "type": "string" |
||
167 | }, |
||
168 | "uid": { |
||
169 | "type": "string" |
||
170 | }, |
||
171 | "name": { |
||
172 | "description": "The name of the action.", |
||
173 | "type": "string", |
||
174 | "required": True |
||
175 | }, |
||
176 | "description": { |
||
177 | "description": "The description of the action.", |
||
178 | "type": "string" |
||
179 | }, |
||
180 | "enabled": { |
||
181 | "description": "Enable or disable the action from invocation.", |
||
182 | "type": "boolean", |
||
183 | "default": True |
||
184 | }, |
||
185 | "runner_type": { |
||
186 | "description": "The type of runner that executes the action.", |
||
187 | "type": "string", |
||
188 | "required": True |
||
189 | }, |
||
190 | "entry_point": { |
||
191 | "description": "The entry point for the action.", |
||
192 | "type": "string", |
||
193 | "default": "" |
||
194 | }, |
||
195 | "pack": { |
||
196 | "description": "The content pack this action belongs to.", |
||
197 | "type": "string", |
||
198 | "default": DEFAULT_PACK_NAME |
||
199 | }, |
||
200 | "parameters": { |
||
201 | "description": "Input parameters for the action.", |
||
202 | "type": "object", |
||
203 | "patternProperties": { |
||
204 | "^\w+$": util_schema.get_action_parameters_schema() |
||
205 | }, |
||
206 | 'additionalProperties': False, |
||
207 | "default": {} |
||
208 | }, |
||
209 | "tags": { |
||
210 | "description": "User associated metadata assigned to this object.", |
||
211 | "type": "array", |
||
212 | "items": {"type": "object"} |
||
213 | }, |
||
214 | "notify": { |
||
215 | "description": "Notification settings for action.", |
||
216 | "type": "object", |
||
217 | "properties": { |
||
218 | "on-complete": NotificationSubSchemaAPI, |
||
219 | "on-failure": NotificationSubSchemaAPI, |
||
220 | "on-success": NotificationSubSchemaAPI |
||
221 | }, |
||
222 | "additionalProperties": False |
||
223 | } |
||
224 | }, |
||
225 | "additionalProperties": False |
||
226 | } |
||
227 | |||
228 | def __init__(self, **kw): |
||
0 ignored issues
–
show
The
__init__ method of the super-class BaseAPI is not called.
It is generally advisable to initialize the super-class by calling its class SomeParent:
def __init__(self):
self.x = 1
class SomeChild(SomeParent):
def __init__(self):
# Initialize the super class
SomeParent.__init__(self)
Loading history...
|
|||
229 | for key, value in kw.items(): |
||
230 | setattr(self, key, value) |
||
231 | if not hasattr(self, 'parameters'): |
||
232 | setattr(self, 'parameters', dict()) |
||
233 | if not hasattr(self, 'entry_point'): |
||
234 | setattr(self, 'entry_point', '') |
||
235 | |||
236 | @classmethod |
||
237 | def from_model(cls, model, mask_secrets=False): |
||
238 | action = cls._from_model(model) |
||
239 | action['runner_type'] = action['runner_type']['name'] |
||
240 | action['tags'] = TagsHelper.from_model(model.tags) |
||
241 | |||
242 | if getattr(model, 'notify', None): |
||
243 | action['notify'] = NotificationsHelper.from_model(model.notify) |
||
244 | |||
245 | return cls(**action) |
||
246 | |||
247 | @classmethod |
||
248 | def to_model(cls, action): |
||
249 | name = getattr(action, 'name', None) |
||
250 | description = getattr(action, 'description', None) |
||
251 | enabled = bool(getattr(action, 'enabled', True)) |
||
252 | entry_point = str(action.entry_point) |
||
253 | pack = str(action.pack) |
||
254 | runner_type = {'name': str(action.runner_type)} |
||
255 | parameters = getattr(action, 'parameters', dict()) |
||
256 | tags = TagsHelper.to_model(getattr(action, 'tags', [])) |
||
257 | ref = ResourceReference.to_string_reference(pack=pack, name=name) |
||
258 | |||
259 | if getattr(action, 'notify', None): |
||
260 | notify = NotificationsHelper.to_model(action.notify) |
||
261 | else: |
||
262 | # We use embedded document model for ``notify`` in action model. If notify is |
||
263 | # set notify to None, Mongoengine interprets ``None`` as unmodified |
||
264 | # field therefore doesn't delete the embedded document. Therefore, we need |
||
265 | # to use an empty document. |
||
266 | notify = NotificationsHelper.to_model({}) |
||
267 | |||
268 | model = cls.model(name=name, description=description, enabled=enabled, |
||
269 | entry_point=entry_point, pack=pack, runner_type=runner_type, |
||
270 | tags=tags, parameters=parameters, notify=notify, |
||
271 | ref=ref) |
||
272 | |||
273 | return model |
||
274 | |||
275 | |||
276 | class ActionCreateAPI(ActionAPI, APIUIDMixin): |
||
277 | """ |
||
278 | API model for create action operation. |
||
279 | """ |
||
280 | schema = copy.deepcopy(ActionAPI.schema) |
||
281 | schema['properties']['data_files'] = { |
||
282 | 'description': 'Optional action script and data files which are written to the filesystem.', |
||
283 | 'type': 'array', |
||
284 | 'items': { |
||
285 | 'type': 'object', |
||
286 | 'properties': { |
||
287 | 'file_path': { |
||
288 | 'type': 'string', |
||
289 | 'description': ('Path to the file relative to the pack actions directory ' |
||
290 | '(e.g. my_action.py)'), |
||
291 | 'required': True |
||
292 | }, |
||
293 | 'content': { |
||
294 | 'type': 'string', |
||
295 | 'description': 'Raw file content.', |
||
296 | 'required': True |
||
297 | }, |
||
298 | }, |
||
299 | 'additionalProperties': False |
||
300 | }, |
||
301 | 'default': [] |
||
302 | } |
||
303 | |||
304 | |||
305 | class ActionUpdateAPI(ActionAPI, APIUIDMixin): |
||
306 | """ |
||
307 | API model for update action operation. |
||
308 | """ |
||
309 | schema = copy.deepcopy(ActionCreateAPI.schema) |
||
310 | del schema['properties']['pack']['default'] |
||
311 | |||
312 | |||
313 | class LiveActionAPI(BaseAPI): |
||
314 | """The system entity that represents the execution of a Stack Action/Automation |
||
315 | in the system. |
||
316 | """ |
||
317 | |||
318 | model = LiveActionDB |
||
319 | schema = { |
||
320 | "title": "liveaction", |
||
321 | "description": "An execution of an action.", |
||
322 | "type": "object", |
||
323 | "properties": { |
||
324 | "id": { |
||
325 | "description": "The unique identifier for the action execution.", |
||
326 | "type": "string" |
||
327 | }, |
||
328 | "status": { |
||
329 | "description": "The current status of the action execution.", |
||
330 | "type": "string", |
||
331 | "enum": LIVEACTION_STATUSES |
||
332 | }, |
||
333 | "start_timestamp": { |
||
334 | "description": "The start time when the action is executed.", |
||
335 | "type": "string", |
||
336 | "pattern": isotime.ISO8601_UTC_REGEX |
||
337 | }, |
||
338 | "end_timestamp": { |
||
339 | "description": "The timestamp when the action has finished.", |
||
340 | "type": "string", |
||
341 | "pattern": isotime.ISO8601_UTC_REGEX |
||
342 | }, |
||
343 | "action": { |
||
344 | "description": "Reference to the action to be executed.", |
||
345 | "type": "string", |
||
346 | "required": True |
||
347 | }, |
||
348 | "parameters": { |
||
349 | "description": "Input parameters for the action.", |
||
350 | "type": "object", |
||
351 | "patternProperties": { |
||
352 | "^\w+$": { |
||
0 ignored issues
–
show
A suspicious escape sequence
\w was found. Did you maybe forget to add an r prefix?
Escape sequences in Python are generally interpreted according to rules similar
to standard C. Only if strings are prefixed with The escape sequence that was used indicates that you might have intended to write a regular expression. Learn more about the available escape sequences. in the Python documentation.
Loading history...
|
|||
353 | "anyOf": [ |
||
354 | {"type": "array"}, |
||
355 | {"type": "boolean"}, |
||
356 | {"type": "integer"}, |
||
357 | {"type": "number"}, |
||
358 | {"type": "object"}, |
||
359 | {"type": "string"}, |
||
360 | {"type": "null"} |
||
361 | ] |
||
362 | } |
||
363 | }, |
||
364 | 'additionalProperties': False |
||
365 | }, |
||
366 | "result": { |
||
367 | "anyOf": [{"type": "array"}, |
||
368 | {"type": "boolean"}, |
||
369 | {"type": "integer"}, |
||
370 | {"type": "number"}, |
||
371 | {"type": "object"}, |
||
372 | {"type": "string"}] |
||
373 | }, |
||
374 | "context": { |
||
375 | "type": "object" |
||
376 | }, |
||
377 | "callback": { |
||
378 | "type": "object" |
||
379 | }, |
||
380 | "runner_info": { |
||
381 | "type": "object" |
||
382 | }, |
||
383 | "notify": { |
||
384 | "description": "Notification settings for liveaction.", |
||
385 | "type": "object", |
||
386 | "properties": { |
||
387 | "on-complete": NotificationSubSchemaAPI, |
||
388 | "on-failure": NotificationSubSchemaAPI, |
||
389 | "on-success": NotificationSubSchemaAPI |
||
390 | }, |
||
391 | "additionalProperties": False |
||
392 | } |
||
393 | }, |
||
394 | "additionalProperties": False |
||
395 | } |
||
396 | |||
397 | @classmethod |
||
398 | def from_model(cls, model, mask_secrets=False): |
||
399 | doc = super(cls, cls)._from_model(model, mask_secrets=mask_secrets) |
||
400 | if model.start_timestamp: |
||
401 | doc['start_timestamp'] = isotime.format(model.start_timestamp, offset=False) |
||
402 | if model.end_timestamp: |
||
403 | doc['end_timestamp'] = isotime.format(model.end_timestamp, offset=False) |
||
404 | |||
405 | if getattr(model, 'notify', None): |
||
406 | doc['notify'] = NotificationsHelper.from_model(model.notify) |
||
407 | |||
408 | return cls(**doc) |
||
409 | |||
410 | @classmethod |
||
411 | def to_model(cls, live_action): |
||
412 | action = live_action.action |
||
413 | |||
414 | if getattr(live_action, 'start_timestamp', None): |
||
415 | start_timestamp = isotime.parse(live_action.start_timestamp) |
||
416 | else: |
||
417 | start_timestamp = None |
||
418 | |||
419 | if getattr(live_action, 'end_timestamp', None): |
||
420 | end_timestamp = isotime.parse(live_action.end_timestamp) |
||
421 | else: |
||
422 | end_timestamp = None |
||
423 | |||
424 | status = getattr(live_action, 'status', None) |
||
425 | parameters = getattr(live_action, 'parameters', dict()) |
||
426 | context = getattr(live_action, 'context', dict()) |
||
427 | callback = getattr(live_action, 'callback', dict()) |
||
428 | result = getattr(live_action, 'result', None) |
||
429 | |||
430 | if getattr(live_action, 'notify', None): |
||
431 | notify = NotificationsHelper.to_model(live_action.notify) |
||
432 | else: |
||
433 | notify = None |
||
434 | |||
435 | model = cls.model(action=action, |
||
436 | start_timestamp=start_timestamp, end_timestamp=end_timestamp, |
||
437 | status=status, parameters=parameters, context=context, |
||
438 | callback=callback, result=result, notify=notify) |
||
439 | |||
440 | return model |
||
441 | |||
442 | |||
443 | class LiveActionCreateAPI(LiveActionAPI): |
||
444 | """ |
||
445 | API model for action execution create (run action) operations. |
||
446 | """ |
||
447 | schema = copy.deepcopy(LiveActionAPI.schema) |
||
448 | schema['properties']['user'] = { |
||
449 | 'description': 'User context under which action should run (admins only)', |
||
450 | 'type': 'string', |
||
451 | 'default': None |
||
452 | } |
||
453 | |||
454 | |||
455 | class ActionExecutionStateAPI(BaseAPI): |
||
456 | """ |
||
457 | System entity that represents state of an action in the system. |
||
458 | This is used only in tests for now. |
||
459 | """ |
||
460 | model = ActionExecutionStateDB |
||
461 | schema = { |
||
462 | "title": "ActionExecutionState", |
||
463 | "description": "Execution state of an action.", |
||
464 | "type": "object", |
||
465 | "properties": { |
||
466 | "id": { |
||
467 | "description": "The unique identifier for the action execution state.", |
||
468 | "type": "string" |
||
469 | }, |
||
470 | "execution_id": { |
||
471 | "type": "string", |
||
472 | "description": "ID of the action execution.", |
||
473 | "required": True |
||
474 | }, |
||
475 | "query_context": { |
||
476 | "type": "object", |
||
477 | "description": "query context to be used by querier.", |
||
478 | "required": True |
||
479 | }, |
||
480 | "query_module": { |
||
481 | "type": "string", |
||
482 | "description": "Name of the query module.", |
||
483 | "required": True |
||
484 | } |
||
485 | }, |
||
486 | "additionalProperties": False |
||
487 | } |
||
488 | |||
489 | @classmethod |
||
490 | def to_model(cls, state): |
||
491 | execution_id = state.execution_id |
||
492 | query_module = state.query_module |
||
493 | query_context = state.query_context |
||
494 | |||
495 | model = cls.model(execution_id=execution_id, query_module=query_module, |
||
496 | query_context=query_context) |
||
497 | return model |
||
498 | |||
499 | |||
500 | class ActionAliasAPI(BaseAPI, APIUIDMixin): |
||
501 | """ |
||
502 | Alias for an action in the system. |
||
503 | """ |
||
504 | model = ActionAliasDB |
||
505 | schema = { |
||
506 | "title": "ActionAlias", |
||
507 | "description": "Alias for an action.", |
||
508 | "type": "object", |
||
509 | "properties": { |
||
510 | "id": { |
||
511 | "description": "The unique identifier for the action alias.", |
||
512 | "type": "string" |
||
513 | }, |
||
514 | "ref": { |
||
515 | "description": "System computed user friendly reference for the alias. \ |
||
516 | Provided value will be overridden by computed value.", |
||
517 | "type": "string" |
||
518 | }, |
||
519 | "uid": { |
||
520 | "type": "string" |
||
521 | }, |
||
522 | "name": { |
||
523 | "type": "string", |
||
524 | "description": "Name of the action alias.", |
||
525 | "required": True |
||
526 | }, |
||
527 | "pack": { |
||
528 | "description": "The content pack this actionalias belongs to.", |
||
529 | "type": "string", |
||
530 | "required": True |
||
531 | }, |
||
532 | "description": { |
||
533 | "type": "string", |
||
534 | "description": "Description of the action alias.", |
||
535 | "default": None |
||
536 | }, |
||
537 | "enabled": { |
||
538 | "description": "Flag indicating of action alias is enabled.", |
||
539 | "type": "boolean", |
||
540 | "default": True |
||
541 | }, |
||
542 | "action_ref": { |
||
543 | "type": "string", |
||
544 | "description": "Reference to the aliased action.", |
||
545 | "required": True |
||
546 | }, |
||
547 | "formats": { |
||
548 | "type": "array", |
||
549 | "items": { |
||
550 | "anyOf": [ |
||
551 | {"type": "string"}, |
||
552 | { |
||
553 | "type": "object", |
||
554 | "properties": { |
||
555 | "display": {"type": "string"}, |
||
556 | "representation": { |
||
557 | "type": "array", |
||
558 | "items": {"type": "string"} |
||
559 | } |
||
560 | } |
||
561 | } |
||
562 | ] |
||
563 | }, |
||
564 | "description": "Possible parameter format." |
||
565 | }, |
||
566 | "ack": { |
||
567 | "type": "object", |
||
568 | "properties": { |
||
569 | "enabled": {"type": "boolean"}, |
||
570 | "format": {"type": "string"}, |
||
571 | "extra": {"type": "object"}, |
||
572 | "append_url": {"type": "boolean"} |
||
573 | }, |
||
574 | "description": "Acknowledgement message format." |
||
575 | }, |
||
576 | "result": { |
||
577 | "type": "object", |
||
578 | "properties": { |
||
579 | "enabled": {"type": "boolean"}, |
||
580 | "format": {"type": "string"}, |
||
581 | "extra": {"type": "object"} |
||
582 | }, |
||
583 | "description": "Execution message format." |
||
584 | }, |
||
585 | "extra": { |
||
586 | "type": "object", |
||
587 | "description": "Extra parameters, usually adapter-specific." |
||
588 | } |
||
589 | }, |
||
590 | "additionalProperties": False |
||
591 | } |
||
592 | |||
593 | @classmethod |
||
594 | def to_model(cls, alias): |
||
595 | name = alias.name |
||
596 | description = getattr(alias, 'description', None) |
||
597 | pack = alias.pack |
||
598 | ref = ResourceReference.to_string_reference(pack=pack, name=name) |
||
599 | enabled = getattr(alias, 'enabled', True) |
||
600 | action_ref = alias.action_ref |
||
601 | formats = alias.formats |
||
602 | ack = getattr(alias, 'ack', None) |
||
603 | result = getattr(alias, 'result', None) |
||
604 | extra = getattr(alias, 'extra', None) |
||
605 | |||
606 | model = cls.model(name=name, description=description, pack=pack, ref=ref, |
||
607 | enabled=enabled, action_ref=action_ref, formats=formats, |
||
608 | ack=ack, result=result, extra=extra) |
||
609 | return model |
||
610 | |||
611 | |||
612 | class AliasExecutionAPI(BaseAPI): |
||
613 | """ |
||
614 | Alias for an action in the system. |
||
615 | """ |
||
616 | model = None |
||
617 | schema = { |
||
618 | "title": "AliasExecution", |
||
619 | "description": "Execution of an ActionAlias.", |
||
620 | "type": "object", |
||
621 | "properties": { |
||
622 | "name": { |
||
623 | "type": "string", |
||
624 | "description": "Name of the action alias which matched.", |
||
625 | "required": True |
||
626 | }, |
||
627 | "format": { |
||
628 | "type": "string", |
||
629 | "description": "Format string which matched.", |
||
630 | "required": True |
||
631 | }, |
||
632 | "command": { |
||
633 | "type": "string", |
||
634 | "description": "Command used in chat.", |
||
635 | "required": True |
||
636 | }, |
||
637 | "user": { |
||
638 | "type": "string", |
||
639 | "description": "User that requested the execution.", |
||
640 | "default": "channel" # TODO: This value doesnt get set |
||
641 | }, |
||
642 | "source_channel": { |
||
643 | "type": "string", |
||
644 | "description": "Channel from which the execution was requested. This is not the \ |
||
645 | channel as defined by the notification system.", |
||
646 | "required": True |
||
647 | }, |
||
648 | "notification_channel": { |
||
649 | "type": "string", |
||
650 | "description": "StackStorm notification channel to use to respond.", |
||
651 | "required": False |
||
652 | }, |
||
653 | "notification_route": { |
||
654 | "type": "string", |
||
655 | "description": "StackStorm notification route to use to respond.", |
||
656 | "required": False |
||
657 | } |
||
658 | }, |
||
659 | "additionalProperties": False |
||
660 | } |
||
661 | |||
662 | @classmethod |
||
663 | def to_model(cls, aliasexecution): |
||
664 | # probably should be unsupported |
||
665 | raise NotImplementedError() |
||
666 | |||
667 | @classmethod |
||
668 | def from_model(cls, aliasexecution): |
||
0 ignored issues
–
show
|
|||
669 | raise NotImplementedError() |
||
670 | |||
671 | |||
672 | class AliasMatchAndExecuteInputAPI(BaseAPI): |
||
673 | """ |
||
674 | API object used for alias execution "match and execute" API endpoint request payload. |
||
675 | """ |
||
676 | model = None |
||
677 | schema = { |
||
678 | "title": "ActionAliasMatchAndExecuteInputAPI", |
||
679 | "description": "Input for alias execution match and execute API.", |
||
680 | "type": "object", |
||
681 | "properties": { |
||
682 | "command": { |
||
683 | "type": "string", |
||
684 | "description": "Command used in chat.", |
||
685 | "required": True |
||
686 | }, |
||
687 | "user": { |
||
688 | "type": "string", |
||
689 | "description": "User that requested the execution.", |
||
690 | }, |
||
691 | "source_channel": { |
||
692 | "type": "string", |
||
693 | "description": "Channel from which the execution was requested. This is not the \ |
||
694 | channel as defined by the notification system.", |
||
695 | "required": True |
||
696 | }, |
||
697 | "notification_channel": { |
||
698 | "type": "string", |
||
699 | "description": "StackStorm notification channel to use to respond.", |
||
700 | "required": False, |
||
701 | "default": None |
||
702 | }, |
||
703 | "notification_route": { |
||
704 | "type": "string", |
||
705 | "description": "StackStorm notification route to use to respond.", |
||
706 | "required": False, |
||
707 | "default": None |
||
708 | } |
||
709 | }, |
||
710 | "additionalProperties": False |
||
711 | } |
||
712 | |||
713 | |||
714 | class ActionAliasMatchAPI(BaseAPI): |
||
715 | """ |
||
716 | API model used for alias match API endpoint. |
||
717 | """ |
||
718 | model = None |
||
719 | |||
720 | schema = { |
||
721 | "title": "ActionAliasMatchAPI", |
||
722 | "description": "ActionAliasMatchAPI.", |
||
723 | "type": "object", |
||
724 | "properties": { |
||
725 | "command": { |
||
726 | "type": "string", |
||
727 | "description": "Command string to try to match the aliases against.", |
||
728 | "required": True |
||
729 | } |
||
730 | }, |
||
731 | "additionalProperties": False |
||
732 | } |
||
733 | |||
734 | @classmethod |
||
735 | def to_model(cls, aliasexecution): |
||
736 | raise NotImplementedError() |
||
737 | |||
738 | @classmethod |
||
739 | def from_model(cls, aliasexecution): |
||
740 | raise NotImplementedError() |
||
741 | |||
742 | |||
743 | class ActionAliasHelpAPI(BaseAPI): |
||
744 | """ |
||
745 | API model used to display action-alias help API endpoint. |
||
746 | """ |
||
747 | model = None |
||
748 | |||
749 | schema = { |
||
750 | "title": "ActionAliasHelpAPI", |
||
751 | "description": "ActionAliasHelpAPI.", |
||
752 | "type": "object", |
||
753 | "properties": { |
||
754 | "filter": { |
||
755 | "type": "string", |
||
756 | "description": "Find help strings containing keyword.", |
||
757 | "required": False, |
||
758 | "default": "" |
||
759 | }, |
||
760 | "pack": { |
||
761 | "type": "string", |
||
762 | "description": "List help strings for a specific pack.", |
||
763 | "required": False, |
||
764 | "default": "" |
||
765 | }, |
||
766 | "offset": { |
||
767 | "type": "integer", |
||
768 | "description": "List help strings from the offset position.", |
||
769 | "required": False, |
||
770 | "default": 0 |
||
771 | }, |
||
772 | "limit": { |
||
773 | "type": "integer", |
||
774 | "description": "Limit the number of help strings returned.", |
||
775 | "required": False, |
||
776 | "default": 0 |
||
777 | } |
||
778 | }, |
||
779 | "additionalProperties": False |
||
780 | } |
||
781 | |||
782 | @classmethod |
||
783 | def to_model(cls, aliasexecution): |
||
784 | raise NotImplementedError() |
||
785 | |||
786 | @classmethod |
||
787 | def from_model(cls, aliasexecution): |
||
788 | raise NotImplementedError() |
||
789 |
It is generally advisable to initialize the super-class by calling its
__init__
method: