Send status request for group/button.
438808
def extended_status_request(self):
        """"""
        self._status_received = False
        user_data = Userdata({'d1': self.group,
                              'd2': 0x00})
        cmd = ExtendedSend(self._address,
                           COMMAND_EXTENDED_GET_SET_0X2E_0X00,
                           userdata=user_data)
        cmd.set_checksum()
        self._send_method(cmd, self._status_message_received, True)
591413
public static void requestConnectionStatus(Context context) {
        Intent intent = new Intent(EventManager.ACTION_CONNECTION_STATUS_REQUEST);
        context.sendBroadcast(intent);
    }
1062930
def groups_kick(self, room_id, user_id, **kwargs):
        """"""
        return self.__call_api_post('groups.kick', roomId=room_id, userId=user_id, kwargs=kwargs)
160823
def status(self, *msg):
        
        label = colors.yellow("STATUS")
        self._msg(label, *msg)
149386
private void requestNotification() {
        AndPermission.with(this)
            .notification()
            .permission()
            .rationale(new NotifyRationale())
            .onGranted(new Action<Void>() {
                @Override
                public void onAction(Void data) {
                    toast(R.string.successfully);
                }
            })
            .onDenied(new Action<Void>() {
                @Override
                public void onAction(Void data) {
                    toast(R.string.failure);
                }
            })
            .start();
    }
243928
def set_status(self, name, text='', row=0, fg='black', bg='white'):
        ''''''
        if self.is_alive():
            self.parent_pipe_send.send(Value(name, text, row, fg, bg))
1224653
def set_group_status(group_id, status, **kwargs):
    
    user_id = kwargs.get('user_id')
    try:
        group_i = db.DBSession.query(ResourceGroup).filter(ResourceGroup.id == group_id).one()
    except NoResultFound:
        raise ResourceNotFoundError("ResourceGroup %s not found"%(group_id))

    group_i.network.check_write_permission(user_id)

    group_i.status = status

    db.DBSession.flush()

    return group_i
1321875
def send(self, command, reps=REPS, wait=MIN_WAIT):
        
        # Enqueue the command.
        self._command_queue.put((command, reps, wait))
        # Wait before accepting another command.
        # This keeps individual groups relatively synchronized.
        sleep = reps * wait * self.active
        if command.select and self._selected_number != command.group_number:
            sleep += SELECT_WAIT
        time.sleep(sleep)
585358
def send_status(status: 'EFBStatus'):
    
    global middlewares, master
    if status is None:
        return

    s: 'Optional[EFBStatus]' = status

    # Go through middlewares
    for i in middlewares:
        s = i.process_status(cast('EFBStatus', s))
        if s is None:
            return

    status = cast('EFBStatus', s)

    status.verify()

    status.destination_channel.send_status(status)
857764
public ApiResponse postGroupActivity(String groupId, Activity activity) {
        return apiRequest(HttpMethod.POST, null, activity, organizationId, applicationId, "groups",
                groupId, "activities");
    }
270590
def _send_heartbeat_request(self):
        """"""
        if self.coordinator_unknown():
            e = Errors.GroupCoordinatorNotAvailableError(self.coordinator_id)
            return Future().failure(e)

        elif not self._client.ready(self.coordinator_id, metadata_priority=False):
            e = Errors.NodeNotReadyError(self.coordinator_id)
            return Future().failure(e)

        version = 0 if self.config['api_version'] < (0, 11, 0) else 1
        request = HeartbeatRequest[version](self.group_id,
                                            self._generation.generation_id,
                                            self._generation.member_id)
        log.debug("Heartbeat: %s[%s] %s", request.group, request.generation_id, request.member_id)  # pylint: disable-msg=no-member
        future = Future()
        _f = self._client.send(self.coordinator_id, request)
        _f.add_callback(self._handle_heartbeat_response, future, time.time())
        _f.add_errback(self._failed_request, self.coordinator_id,
                       request, future)
        return future
822639
def send(self, group_id=None, message_dict=None):
        
        if self.group is not None and self.group.id is not None:
            group_id = self.group.id

        path = 'message/%s' % group_id

        if message_dict is not None:
            request_data = {
                'message': message_dict,
            }
        else:
            subject = self.subject
            text = self.text
            markdown = self.markdown

            request_data = {
                'message': {},
            }
            if subject:
                request_data['message']['subject'] = subject
            if text:
                request_data['message']['text'] = text
            if markdown:
                request_data['message']['markdown'] = markdown

        response_data = self.api.request(path, request_data)

        self.id = response_data['message_id']
        self.thread_id = response_data['thread_id']
        self.sent_message = FiestaMessage(self.api, response_data['message'])
1116494
def send_group_image(self, sender, receiver, media_id):
        
        return self.send_image(sender, 'group', receiver, media_id)
1176969
def sendStatusPing(self):
        
        data = parse.urlencode({"key": self.key, "version": self.version}).encode()
        req = request.Request("https://redunda.sobotics.org/status.json", data)

        response = request.urlopen(req)

        jsonReturned = json.loads(response.read().decode("utf-8"))

        self.location = jsonReturned["location"]
        self.shouldStandby = jsonReturned["should_standby"]
        self.eventCount = jsonReturned["event_count"]
869496
def handle_status(self):
        """"""
        status = self.get_status()

        if status:
            # Update main-zone
            self.zones['main'].update_status(status)
230715
private void processCommonFilterStatus(final TargetUpdateStatus status, final boolean buttonPressed) {
        if (buttonPressed) {
            buttonClicked.addStyleName(BTN_CLICKED);
            managementUIState.getTargetTableFilters().getClickedStatusTargetTags().add(status);
            eventBus.publish(this, TargetFilterEvent.FILTER_BY_STATUS);

        } else {
            buttonClicked.removeStyleName(BTN_CLICKED);
            managementUIState.getTargetTableFilters().getClickedStatusTargetTags().remove(status);
            eventBus.publish(this, TargetFilterEvent.REMOVE_FILTER_BY_STATUS);
        }

    }
227952
private function sendStatus()
    {
        if (headers_sent()) return;

        if (isset($this->status_messages[$this->status])) {
            header(sprintf('HTTP/%s %d %s', $this->request->getHttpVersion(), $this->status, $this->status_messages[$this->status]));
        } else {
            header('Status: ' . $this->status);
        }
    }