Check a single organization
510248
public function checkAllAction()
    {
        $batch = $this->loader->getTaskRunnerBatch('orgCheckAll');
        if (! $batch->isLoaded()) {

            $sql = "SELECT gr2o_id_user, gr2o_id_organization
                        FROM gems__respondent2org INNER JOIN gems__reception_codes ON gr2o_reception_code = grc_id_reception_code
                        WHERE grc_success = 1
                        ORDER BY gr2o_id_organization, gr2o_created";

            // \MUtil_Echo::track($sql);

            $rows = $this->db->fetchAll($sql);

            foreach ($rows as $row) {
                $batch->addTask('Respondent\\UpdateRespondentTask', $row['gr2o_id_user'], $row['gr2o_id_organization']);
            }
        }

        $title = $this->_("Checking all respondents.");
        $this->_helper->BatchRunner($batch, $title, $this->accesslog);

        $this->addSnippet('Organization\\CheckOrganizationInformation');
    }
895406
def check(self, check, member, missing=False):
        """"""
        if missing:
            raise self.baseErrorClass()
        return member
885407
def check(self, check_all=True, do_reload=True):
        """"""
        with enaml.imports():
            super(EnamlReloader, self).check(check_all=check_all, do_reload=do_reload)
1001651
def instance_contains(container, item):
    """"""
    return item in (member for _, member in inspect.getmembers(container))
245979
def _find_single(self, match_class, **keywds):
        """"""
        self._logger.debug('find single query execution - started')
        start_time = timeit.default_timer()
        norm_keywds = self.__normalize_args(**keywds)
        decl_matcher = self.__create_matcher(match_class, **norm_keywds)
        dtype = self.__findout_decl_type(match_class, **norm_keywds)
        recursive_ = self.__findout_recursive(**norm_keywds)
        decls = self.__findout_range(norm_keywds['name'], dtype, recursive_)
        found = matcher.get_single(decl_matcher, decls, False)
        self._logger.debug(
            'find single query execution - done( %f seconds )',
            (timeit.default_timer() - start_time))
        return found
629504
def check(self):
        ""
        config = self.load_config()
        if not check_dependency_epubcheck():
            sys.exit(error('Unavailable command.'))
        epub_file = u"%s.epub" % config['fileroot']
        epub_path = join(CWD, 'build', epub_file)
        print success("Starting to check %s..." % epub_file)
        epubcheck = u'epubcheck %s' % epub_path
        epubcheck = shell(epubcheck.encode())
        for line in epubcheck.errors():
            print error(line)
        for line in epubcheck.output():
            print line
1007827
def CheckTotals(self):
        """"""
        staves = self.GetChildrenIndexes()
        for staff in staves:
            child = self.getStaff(staff)
            child.CheckTotals()
137522
def system_find_orgs(input_params={}, always_retry=True, **kwargs):
    
    return DXHTTPRequest('/system/findOrgs', input_params, always_retry=always_retry, **kwargs)
247690
def validate_single_association(reflection)
        association = association_instance_get(reflection.name)
        record      = association && association.reader
        association_valid?(reflection, record) if record
      end
871792
function findGroupsByCheck(groups, compareFn) {
    var foundGroups = groups.filter(compareFn);
    groups.forEach(function(group) {
        var subFound = findGroupsByCheck(group.getGroups(), compareFn);
        if (subFound.length > 0) {
            foundGroups = foundGroups.concat(subFound);
        }
    });
    return foundGroups;
}
765183
def organization(self):
        
        if self.api and self.organization_id:
            return self.api._get_organization(self.organization_id)
887716
def check(self):  # pragma: no cover
        """"""
        for unsorted in iter(self[i] for i in range(len(self) - 2) if not operator.le(self[i], self[i + 1])):
            self.resort(unsorted)
725284
def checkin(self):
        """"""
        self._query_instance.checkin(self.place_id,
                                     self._query_instance.sensor)
879639
def _check_for_single_nested(target, items_by_key, input_order):
    
    out = utils.deepish_copy(items_by_key)
    for (k, t) in input_order.items():
        if t == "var":
            v = items_by_key[tuple(k.split("__"))]
            if _is_nested_single(v, target):
                out[tuple(k.split("__"))] = v[0]
    return out
77018
def get_organization(self, id=None, name=None):
        
        log.info("Picking organization: %s (%s)" % (name, id))
        return self.organizations[id or name]
1365924
def checks(self):
        ''''''
        condition = lambda a: a.startswith('check_')
        return (getattr(self, a) for a in dir(self) if condition(a))
443721
def check_authorization
        unless current_user
          render nothing: true, status: :unauthorized
          return false
        end
        if params[:organization_id] && !parent_organization
          render nothing: true, status: :forbidden
          return false
        end
        true
      end