problems.add(new DefaultSettingsProblem(
                                "Legacy/insecurely encrypted password detected for server " + server.getId(),
                                Severity.WARNING,
                                "server: " + server.getId(),
                                -1,
                                -1,
                                null));
                    }

 */
package jcifs.internal;


/**
 * @author mbechler
 *
 */
public interface TreeConnectResponse extends CommonServerMessageBlockResponse {

    /**
     * @return tree id
     */
    int getTid ();


    /**
     * @return service
     */
    String getService ();


    /**
     * @return whether the share is in DFS
     */
    boolean isShareDfs ();


    /**

     * @return the message id
     */
    long getMid ();


    /**
     * @param mid
     */
    void setMid ( long mid );


    /**
     * @return the command
     */
    int getCommand ();


    /**
     * @param command
     */
    void setCommand ( int command );


    /**
     * @param uid
     */
    void setUid ( int uid );


    /**

        Document document = parent.getOwnerDocument();

        Element section = document.createElement("section");
        parent.appendChild(section);
        section.setAttribute("id", blockDoc.getId());
        section.setAttribute("role", "detail");

        Element title = document.createElement("title");
        section.appendChild(title);
        Element literal = document.createElement("literal");

            final Map<String, Object> params = new HashMap<>();
            ComponentUtil.getComponent(ScheduledJobBhv.class).selectByPK(scheduledJob.getId())
                    .ifPresent(e -> params.put(Constants.SCHEDULED_JOB, e)).orElse(() -> {
                        logger.warn("Job {} is not found.", scheduledJob.getId());
                    });
            return params;
        };
        findJobByUniqueOf(LaJobUnique.of(id)).ifPresent(job -> {

    public void stop() {
        ComponentUtil.getJobManager().findJobByUniqueOf(LaJobUnique.of(getId())).ifPresent(job -> {
            job.stopNow();
        }).orElse(() -> {
            throw new JobNotFoundException(this);
        });
    }

    public String getId() {
        return asDocMeta().id();
    }

    public void setId(final String id) {
        asDocMeta().id(id);
    }

    public Long getVersionNo() {

        boolean activatedPomProfileNotByDefault = false;

        for (Profile profile : profiles) {
            if (!deactivatedIds.contains(profile.getId())) {
                if (activatedIds.contains(profile.getId()) || isActive(profile, context, problems)) {
                    activeProfiles.add(profile);

                    if (Profile.SOURCE_POM.equals(profile.getSource())) {

        // with multiple local repository implementations yet.
        artifact.setFile(artifactFile);

        return artifact;
    }

    @Override
    public String getId() {
        return localRepository.getId();
    }

    @Override
    public String pathOfLocalRepositoryMetadata(ArtifactMetadata metadata, ArtifactRepository repository) {

            return null;
        });
        protwordsService.store(body.dictId, entity);
        return asJson(
                new ApiResult.ApiUpdateResponse().id(String.valueOf(entity.getId())).created(true).status(ApiResult.Status.OK).result());
    }

    // POST /api/admin/dict/protwords/setting/{dictId}
    @Execute
    public JsonResponse<ApiResult> post$setting(final String dictId, final EditBody body) {

            return null;
        });
        kuromojiService.store(body.dictId, entity);
        return asJson(
                new ApiResult.ApiUpdateResponse().id(String.valueOf(entity.getId())).created(true).status(ApiResult.Status.OK).result());
    }

    // POST /api/admin/dict/kuromoji/setting/{dictId}
    @Execute
    public JsonResponse<ApiResult> post$setting(final String dictId, final EditBody body) {