Lists members of a group trigger
 @param [String] trigger_id ID of the group trigger to list members
 @param [boolean] orphans flag to include orphans
 @return [Array<Trigger>] Members found
496123
def list_members(trigger_id, orphans = false)
      ret = http_get "triggers/groups/#{trigger_id}/members?includeOrphans=#{orphans}"
      ret.collect { |t| Trigger.new(t) }
    end
878493
def fetchGroupInfo(self, *group_ids):
        
        threads = self.fetchThreadInfo(*group_ids)
        groups = {}
        for id_, thread in threads.items():
            if thread.type == ThreadType.GROUP:
                groups[id_] = thread
            else:
                raise FBchatUserError("Thread {} was not a group".format(thread))

        return groups
1007030
protected function updateTrigger($trigger_id)
    {
        if (!$this->isError() && !$this->trigger->update($trigger_id, $this->getSubmitted())) {
            $this->errorAndExit($this->text('Unexpected result'));
        }
    }
720637
def trigger(self, event, filter=None, update=None, documents=None, ids=None, replacements=None):
        

        if not self.has_trigger(event):
            return

        if documents is not None:
            pass
        elif ids is not None:
            documents = self.find_by_ids(ids, read_use="primary")
        elif filter is not None:
            documents = self.find(filter, read_use="primary")
        else:
            raise Exception("Trigger couldn't filter documents")

        for doc in documents:
            getattr(doc, event)(update=update, replacements=replacements)
73403
def update(self, trigger_id, full_trigger):
        
        data = self._serialize_object(full_trigger)
        rdict = self._put(self._service_url(['triggers', 'trigger', trigger_id]), data)
        return FullTrigger(rdict)
643544
@Override
	public List<? extends Trigger> getTriggers(JobKey jobKey) throws SchedulerException {
		List<Trigger> triggers = new ArrayList<>();
		if (!CollectionUtils.isEmpty(scheduler.getTriggersOfJob(jobKey))) {
			triggers.addAll(scheduler.getTriggersOfJob(jobKey));
			Collections.sort(triggers, new Comparator<Trigger>() {
				@Override
				public int compare(Trigger o1, Trigger o2) {
					return o1.getKey().compareTo(o2.getKey());
				}
			});
		}
		return triggers;
	}
48928
def _parse_group(self, element):
        
        self._log.debug('Adding Trigger group: {group}'.format(group=element.text))
        if isinstance(self.groups, set):
            self.groups.add(element.text)
        elif self.groups is None:
            self.groups = {element.text}
        else:
            raise TypeError('Unrecognized group type, {type}: {groups}'
                            .format(type=type(self.groups), groups=str(self.groups)))
1061743
def check_orphaned(self):
        
        orphans_count = {}
        now = int(time.time())
        actions = list(self.checks.values()) + list(self.actions.values())
        for chk in actions:
            if chk.status not in [ACT_STATUS_POLLED]:
                continue

            time_to_orphanage = self.find_item_by_id(chk.ref).get_time_to_orphanage()
            if not time_to_orphanage:
                continue

            if chk.t_to_go > now - time_to_orphanage:
                continue

            logger.info("Orphaned %s (%d s / %s / %s) check for: %s (%s)",
                        chk.is_a, time_to_orphanage, chk.t_to_go, now,
                        self.find_item_by_id(chk.ref).get_full_name(), chk)
            chk._is_orphan = True
            chk.status = ACT_STATUS_SCHEDULED
            if chk.my_worker not in orphans_count:
                orphans_count[chk.my_worker] = 0
            orphans_count[chk.my_worker] += 1

        for sta_name in orphans_count:
            logger.warning("%d actions never came back for the satellite '%s'. "
                           "I reenable them for polling.",
                           orphans_count[sta_name], sta_name)
657090
def trigger(self_, *param_names):
        
        events = self_.self_or_cls.param._events
        watchers = self_.self_or_cls.param._watchers
        self_.self_or_cls.param._events  = []
        self_.self_or_cls.param._watchers = []
        param_values = dict(self_.get_param_values())
        params = {name: param_values[name] for name in param_names}
        self_.self_or_cls.param._TRIGGER = True
        self_.set_param(**params)
        self_.self_or_cls.param._TRIGGER = False
        self_.self_or_cls.param._events = events
        self_.self_or_cls.param._watchers = watchers
85969
@Override
	public JobTriggerTO getTriggerInfo(String groupName, String jobName, final String triggerGroup, final String triggerName) throws SchedulerException {
		JobDetail detail = findJob(groupName, jobName);
		
		JobTriggerTO triggerTO = new JobTriggerTO();
		triggerTO.setJobGroup(groupName);
		triggerTO.setJobName(jobName);
		triggerTO.setDescription(detail.getDescription());
		
		triggerTO.setJobData(detail.getJobDataMap());
		
		if (null == triggerName) {
			return triggerTO;
		}
		Trigger trigger = findTrigger(groupName, jobName, triggerGroup, triggerName);
		triggerTO.setTriggerName(triggerName);
		triggerTO.setTriggerGroup(trigger.getKey().getGroup());
		triggerTO.setTriggerDescription(trigger.getDescription());
		
		triggerTO.setMisfireInstruction(trigger.getMisfireInstruction());
		triggerTO.setPriority(trigger.getPriority());
		triggerTO.setCalendarName(trigger.getCalendarName());
		triggerTO.setStartTime(trigger.getStartTime());
		
		if (isCronTrigger(trigger)) {
			addSimilarMisfireInstructionSet(triggerTO, null, TriggerType.CRON);
			triggerTO.setCronExpression(((CronTrigger)trigger).getCronExpression());
			triggerTO.setTimeZone(((CronTrigger)trigger).getTimeZone());
		} else if (trigger instanceof SimpleTrigger) {
			addSimpleMisfireInstructionSet(triggerTO, null);
			triggerTO.setRepeatCount(((SimpleTrigger)trigger).getRepeatCount());
			triggerTO.setRepeatInterval(((SimpleTrigger)trigger).getRepeatInterval());
		} else if (trigger instanceof CalendarIntervalTrigger) {
			addSimilarMisfireInstructionSet(triggerTO, null, TriggerType.CALENDAR);
			triggerTO.setRepeatInterval(Long.valueOf(((CalendarIntervalTrigger)trigger).getRepeatInterval()));
			triggerTO.setRepeatIntervalUnit(((CalendarIntervalTrigger)trigger).getRepeatIntervalUnit());
		} else if (trigger instanceof DailyTimeIntervalTrigger) {
			addSimilarMisfireInstructionSet(triggerTO, null, TriggerType.DAILY);
			triggerTO.setRepeatInterval(Long.valueOf(((DailyTimeIntervalTrigger)trigger).getRepeatInterval()));
			triggerTO.setRepeatIntervalUnit(((DailyTimeIntervalTrigger)trigger).getRepeatIntervalUnit());
			triggerTO.setRepeatCount(((DailyTimeIntervalTrigger)trigger).getRepeatCount());
		}
		
		triggerTO.setJobData(trigger.getJobDataMap());
		
		addGlobalMisfireInstructionSet(triggerTO, null);
		
		return triggerTO;
	}
461845
public static List<TriggerDto> transformToDto(List<Trigger> triggers) {
        List<TriggerDto> result = new ArrayList<TriggerDto>();

        for (Trigger trigger : triggers) {
            result.add(transformToDto(trigger));
        }
        return result;
    }
1314152
def get_single_trigger(trigger_id, full = false)
      the_trigger = '/triggers/' + trigger_id
      ret = http_get(the_trigger)
      trigger = Trigger.new(ret)

      if full
        ret = http_get(the_trigger + '/conditions')
        ret.each { |c| trigger.conditions.push(Trigger::Condition.new(c)) }
        ret = http_get(the_trigger + '/dampenings')
        ret.each { |c| trigger.dampenings.push(Trigger::Dampening.new(c)) }
      end

      trigger
    end
209462
def list_orphan_networks
      Models::Network.where(orphaned: true).map do |network|
        {
          'name' => network.name,
          'type' => network.type,
          'created_at' => network.created_at.to_s,
          'orphaned_at' => network.orphaned_at.to_s,
        }
      end
    end
396541
def aggregation
      agg = DPLA::MAP::Aggregation.new(id)
      return nil unless agg.exists?
      agg.get
      agg
    end
642918
def trigger_revisions(self, trigger_id, **kwargs):
        ""
        api_path = "/api/v2/triggers/{trigger_id}/revisions.json"
        api_path = api_path.format(trigger_id=trigger_id)
        return self.call(api_path, **kwargs)
648917
def ib_group_member_list(self, group_id):
        '''  '''
        req_hook = 'pod/v1/admin/group/' + group_id + '/membership/list'
        req_args = None
        status_code, response = self.__rest__.GET_query(req_hook, req_args)
        self.logger.debug('%s: %s' % (status_code, response))
        return status_code, response
999961
def members
      NippoCore::User.joins(:group_member_relations)
                     .where(nippo_core_group_member_relations: {group_id: self.id})
                     .where.not(nippo_core_group_member_relations: {accepted_at: nil})
    end