:param trigger: trigger object
        :param note_store: note_store object
        :return: note object
972136
def _notebook(trigger, note_store):
        
        note = Types.Note()
        if trigger.notebook:
            # get the notebookGUID ...
            notebook_id = EvernoteMgr.get_notebook(note_store, trigger.notebook)
            # create notebookGUID if it does not exist then return its id
            note.notebookGuid = EvernoteMgr.set_notebook(note_store, trigger.notebook, notebook_id)

            if trigger.tag:
                # ... and get the tagGUID if a tag has been provided
                tag_id = EvernoteMgr.get_tag(note_store, trigger.tag)
                if tag_id is False:
                    tag_id = EvernoteMgr.set_tag(note_store, trigger.tag, tag_id)
                    # set the tag to the note if a tag has been provided
                    if tag_id:
                        note.tagGuids = tag_id

            logger.debug("notebook that will be used %s", trigger.notebook)
        return note
158417
function ReplayHandler (disp, store, def, options) {
  this.dispatcher = disp;

  this.store = store;

  def = def || {};

  this.definition = {
    correlationId: 'correlationId', // optional
    id: 'id',                       // optional
    name: 'name',                   // optional
//      aggregateId: 'aggregate.id',    // optional
//      context: 'context.name',        // optional
//      aggregate: 'aggregate.name',    // optional
    payload: 'payload'              // optional
//      revision: 'revision'            // optional
//      version: 'version',             // optional
//      meta: 'meta'                    // optional, if defined theses values will be copied to the notification (can be used to transport information like userId, etc..)
  };

  this.definition = _.defaults(def, this.definition);

  options = options || {};

  this.options = options;
}
991933
def get_notebook(note_store, my_notebook):
        
        notebook_id = 0
        notebooks = note_store.listNotebooks()
        # get the notebookGUID ...
        for notebook in notebooks:
            if notebook.name.lower() == my_notebook.lower():
                notebook_id = notebook.guid
                break
        return notebook_id
924102
def read_data(self, **kwargs):
        
        model = get_model(kwargs['app_label'], kwargs['model_name'])

        return model.objects.get(trigger_id=kwargs['trigger_id'])
1354243
def trigger(self, target: str, trigger: str, parameters: Dict[str, Any]={}):
		
		pass
262046
function subscribeToKeys(keys_to_watch_for_changes, callback) {
    if (!Array.isArray(keys_to_watch_for_changes)) {
      throw keys_to_watch_for_changes + ' must be an array';
    }

    // add keys that map to the store's keys
    var _iteratorNormalCompletion2 = true;
    var _didIteratorError2 = false;
    var _iteratorError2 = undefined;

    try {
      for (var _iterator2 = keys_to_watch_for_changes[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
        var k = _step2.value;

        if (!store._store.hasOwnProperty(k)) {
          throw 'Store does not have key ' + k;
        }
        store._recordKeySubscriber(k, callback.name);
      }

      // call this function whenever the store changes
    } catch (err) {
      _didIteratorError2 = true;
      _iteratorError2 = err;
    } finally {
      try {
        if (!_iteratorNormalCompletion2 && _iterator2.return) {
          _iterator2.return();
        }
      } finally {
        if (_didIteratorError2) {
          throw _iteratorError2;
        }
      }
    }

    function _callback(changed_keys) {
      if (intersection(keys_to_watch_for_changes, changed_keys).length) {
        callback(changed_keys);
      }
    }
    return store.subscribe(_callback);
  }
1179331
def add_note(self, note):
        
        for n in self.selected_tracks:
            self.tracks[n] + note
134013
def create_dampening(self, trigger_id, dampening):
        
        data = self._serialize_object(dampening)
        url = self._service_url(['triggers', trigger_id, 'dampenings'])
        return Dampening(self._post(url, data))
918363
def get_current_shutit_pexpect_session(self, note=None):
		
		self.handle_note(note)
		res = self.current_shutit_pexpect_session
		self.handle_note_after(note)
		return res
786343
def _create_entry(self, url, title, tags):
        
        try:
            self.pocket.add(url=url, title=title, tags=tags)
            sentence = str('pocket {} created').format(url)
            logger.debug(sentence)
            status = True
        except Exception as e:
            logger.critical(e)
            update_result(self.trigger_id, msg=e, status=False)
            status = False
        return status
137933
def get_function_for_cognito_trigger(self, trigger):
        
        print("get_function_for_cognito_trigger", self.settings.COGNITO_TRIGGER_MAPPING, trigger, self.settings.COGNITO_TRIGGER_MAPPING.get(trigger))
        return self.settings.COGNITO_TRIGGER_MAPPING.get(trigger)
1085689
def create_group(self, trigger):
        
        data = self._serialize_object(trigger)
        return Trigger(self._post(self._service_url(['triggers', 'groups']), data))
258925
def update_credit_note_item(self, credit_note_item_id, credit_note_item_dict):
        
        return self._create_put_request(
            resource=CREDIT_NOTE_ITEMS,
            billomat_id=credit_note_item_id,
            send_data=credit_note_item_dict
        )
1289786
def post_note(self):
        
        if self.args.note_title:
            note_title = self.args.note_title
        else:
            note_title = None

        note_content = self.args.note_content
        mynote = self.pump.Note(display_name=note_title, content=note_content)
        mynote.to = self.pump.me.followers
        mynote.cc = self.pump.Public
        mynote.send()

        return mynote.id or None
477480
public void setNote(String note) {
       try {
           staticTableHistory.updateNote(historyId, note);
           httpMessageCachedData.setNote(note != null && note.length() > 0);
           notifyEvent(HistoryReferenceEventPublisher.EVENT_NOTE_SET);
       } catch (DatabaseException e) {
           log.error(e.getMessage(), e);
       }
       
   }
1254804
def trigger_create(self, data, **kwargs):
        ""
        api_path = "/api/v2/triggers"
        return self.call(api_path, method="POST", data=data, **kwargs)
449025
function processPulledRecord(chain, tableName, pulledRecord) {
        return chain.then(function() {

            // Update the store as per the pulled record 
            return storeTaskRunner.run(function() {
                if (Validate.isValidId(pulledRecord[idPropertyName])) {
                    throw new Error('Pulled record does not have a valid ID');
                }
                
                return operationTableManager.readPendingOperations(tableName, pulledRecord[idPropertyName]).then(function(pendingOperations) {
                    // If there are pending operations for the record we just pulled, we ignore it.
                    if (pendingOperations.length > 0) {
                        return;
                    }

                    if (pulledRecord[sysProps.deletedColumnName] === true) {
                        return store.del(tableName, pulledRecord.id);
                    } else if (pulledRecord[sysProps.deletedColumnName] === false) {
                        return store.upsert(tableName, pulledRecord);
                    } else {
                        throw new Error("'" + sysProps.deletedColumnName + "' system property is missing. Pull cannot work without it.'");
                    }
                });
            });
        });
    }