Disables a workflow.

 @param resource_group_name [String] The resource group name.
 @param workflow_name [String] The workflow name.
 @param custom_headers [Hash{String => String}] A hash of custom headers that
 will be added to the HTTP request.
168120
def disable(resource_group_name, workflow_name, custom_headers:nil)
      response = disable_async(resource_group_name, workflow_name, custom_headers:custom_headers).value!
      nil
    end
838100
public RestApiConfig disableGroups(RestEndpointGroup... endpointGroups) {
        if (endpointGroups != null) {
            enabledGroups.removeAll(Arrays.asList(endpointGroups));
        }
        return this;
    }
824872
def destroy
      @workflow.destroy

      respond_to do |format|
        format.html { redirect_to workflows_url }
        format.json { head :no_content }
      end
    end
362629
public function setGroupHeaderByNumber($query_name, $header_number, $header_column, $header_custom, $show_in_html = "yes", $show_in_pdf = "yes")
    {
        $hn = (int) $header_number;
        if (!$this->checkGroupNameR("createGroupHeader", $query_name)) {
            ReporticoApp::handleError("Failure in Group Column Header: Unknown Group Name $query_name");
            return;
        }

        if (!$this->checkColumnNameR("createGroupHeader", $header_column)) {
            ReporticoApp::handleError("Failure in Group Column Header: Unknown Column $header_column");
            return;
        }

        $grp = ReporticoUtility::getGroupColumn($query_name, $this->groups);
        $col = ReporticoUtility::getQueryColumn($header_column, $this->columns);
        $header = array();
        $header["GroupHeaderColumn"] = $col;
        $header["GroupHeaderCustom"] = $header_custom;
        $header["ShowInHTML"] = $show_in_html;
        $header["ShowInPDF"] = $show_in_pdf;
        $grp->headers[$hn] = $header;
        //$this->headers[] = $header;
    }
1008499
public void terminateWorkflow(String workflowId, String reason) {
        Preconditions.checkArgument(StringUtils.isNotBlank(workflowId), "workflow id cannot be blank");
        delete(new Object[]{"reason", reason}, "workflow/{workflowId}", workflowId);
    }
168366
def delete(name):
    '''
    
    '''
    if salt.utils.stringutils.contains_whitespace(name):
        raise SaltInvocationError('Group name cannot contain whitespace')
    if name.startswith('_'):
        raise SaltInvocationError(
            'Salt will not remove groups beginning with underscores'
        )
    if not info(name):
        return True
    cmd = ['dseditgroup', '-o', 'delete', name]
    return __salt__['cmd.retcode'](cmd, python_shell=False) == 0
1195235
public void removeWorkflow(String workflowId, boolean archiveWorkflow) {
        try {
            Workflow workflow = getWorkflowById(workflowId, true);

            // remove workflow from ES
            if (archiveWorkflow) {
                //Add to elasticsearch
                indexDAO.updateWorkflow(workflowId,
                        new String[]{RAW_JSON_FIELD, ARCHIVED_FIELD},
                        new Object[]{objectMapper.writeValueAsString(workflow), true});
            } else {
                // Not archiving, also remove workflowId from index
                indexDAO.removeWorkflow(workflowId);
            }

            // remove workflow from DAO
            try {
                executionDAO.removeWorkflow(workflowId);
            } catch (Exception ex) {
                Monitors.recordDaoError("executionDao", "removeWorkflow");
                throw ex;
            }

        } catch (Exception e) {
            throw new ApplicationException(ApplicationException.Code.BACKEND_ERROR, "Error removing workflow: " + workflowId, e);
        }
    }
1102545
def begin_delete(resource_group_name, policy_name, custom_headers:nil)
      response = begin_delete_async(resource_group_name, policy_name, custom_headers:custom_headers).value!
      nil
    end
635802
public void skipTaskFromWorkflow(String workflowId, String taskReferenceName) {
        Preconditions.checkArgument(StringUtils.isNotBlank(workflowId), "workflow id cannot be blank");
        Preconditions.checkArgument(StringUtils.isNotBlank(taskReferenceName), "Task reference name cannot be blank");
        stub.skipTaskFromWorkflow(WorkflowServicePb.SkipTaskRequest.newBuilder()
                .setWorkflowId(workflowId)
                .setTaskReferenceName(taskReferenceName)
                .build()
        );
    }
685384
public Observable<ServiceResponse<Object>> listSwaggerWithServiceResponseAsync(String resourceGroupName, String workflowName) {
        if (this.client.subscriptionId() == null) {
            throw new IllegalArgumentException("Parameter this.client.subscriptionId() is required and cannot be null.");
        }
        if (resourceGroupName == null) {
            throw new IllegalArgumentException("Parameter resourceGroupName is required and cannot be null.");
        }
        if (workflowName == null) {
            throw new IllegalArgumentException("Parameter workflowName is required and cannot be null.");
        }
        if (this.client.apiVersion() == null) {
            throw new IllegalArgumentException("Parameter this.client.apiVersion() is required and cannot be null.");
        }
        return service.listSwagger(this.client.subscriptionId(), resourceGroupName, workflowName, this.client.apiVersion(), this.client.acceptLanguage(), this.client.userAgent())
            .flatMap(new Func1<Response<ResponseBody>, Observable<ServiceResponse<Object>>>() {
                @Override
                public Observable<ServiceResponse<Object>> call(Response<ResponseBody> response) {
                    try {
                        ServiceResponse<Object> clientResponse = listSwaggerDelegate(response);
                        return Observable.just(clientResponse);
                    } catch (Throwable t) {
                        return Observable.error(t);
                    }
                }
            });
    }
956097
@PUT
  @Path("/{path: .*}")
  public void disable(@PathParam("path") String path, @HeaderParam("Authorization") @DefaultValue("no token") String auth) throws Exception {
    sendJGroupsMessage(UpdateOpteration.DISABLE, path, auth);
  }
441930
public Observable<Void> enableAsync(String resourceGroupName, String workflowName) {
        return enableWithServiceResponseAsync(resourceGroupName, workflowName).map(new Func1<ServiceResponse<Void>, Void>() {
            @Override
            public Void call(ServiceResponse<Void> response) {
                return response.body();
            }
        });
    }
911231
public void setResourceAwsIamAccessKeyUserName(java.util.Collection<StringFilter> resourceAwsIamAccessKeyUserName) {
        if (resourceAwsIamAccessKeyUserName == null) {
            this.resourceAwsIamAccessKeyUserName = null;
            return;
        }

        this.resourceAwsIamAccessKeyUserName = new java.util.ArrayList<StringFilter>(resourceAwsIamAccessKeyUserName);
    }
581084
public void setGroupList(CmsPublishGroupList groups, boolean newData, String defaultWorkflow) {

        if (groups.getToken() == null) {
            setGroups(groups.getGroups(), newData, defaultWorkflow);
            setShowResources(true, "");
        } else {
            setShowResources(false, groups.getTooManyResourcesMessage());
        }
        boolean isDirectPublish = m_publishDialog.getPublishOptions().getProjectId().equals(m_directPublishId);
        m_checkboxAddContents.setVisible(isDirectPublish);
    }
423203
public void setWorkflowState(java.util.Collection<StringFilter> workflowState) {
        if (workflowState == null) {
            this.workflowState = null;
            return;
        }

        this.workflowState = new java.util.ArrayList<StringFilter>(workflowState);
    }
360340
public static base_response disable(nitro_service client) throws Exception {
		reporting disableresource = new reporting();
		return disableresource.perform_operation(client,"disable");
	}
603961
def usergroups_disable(self, *, usergroup: str, **kwargs) -> SlackResponse:
        
        self._validate_xoxp_token()
        kwargs.update({"usergroup": usergroup})
        return self.api_call("usergroups.disable", json=kwargs)