Exemplo n.º 1
0
  public static StateConditionType initialize() {
    final ConfigDescriptionParameter state =
        ConfigDescriptionParameterBuilder.create(CONFIG_STATE, Type.TEXT)
            .withRequired(true)
            .withReadOnly(true)
            .withMultiple(false)
            .withLabel("State")
            .withDescription("State of the unit")
            .build();

    final List<ConfigDescriptionParameter> config = new ArrayList<ConfigDescriptionParameter>();
    config.add(state);

    Input leftOperand =
        new Input(
            INPUT_CURRENT_STATE,
            String.class.getName(),
            "Current State",
            "Current state of the unit",
            null,
            true,
            null,
            null);
    List<Input> input = new ArrayList<Input>();
    input.add(leftOperand);
    return new StateConditionType(config, input);
  }
  public static List<ConfigDescriptionParameter> getLocalizedConfigurationDescription(
      I18nProvider i18nProvider,
      List<ConfigDescriptionParameter> config,
      Bundle bundle,
      String uid,
      String prefix,
      Locale locale) {
    List<ConfigDescriptionParameter> configDescriptions =
        new ArrayList<ConfigDescriptionParameter>();
    if (config != null) {
      for (ConfigDescriptionParameter parameter : config) {
        String parameterName = parameter.getName();
        String llabel =
            getModuleTypeConfigParameterLabel(
                i18nProvider, bundle, uid, parameterName, parameter.getLabel(), prefix, locale);
        String ldescription =
            getModuleTypeConfigParameterDescription(
                i18nProvider,
                bundle,
                uid,
                parameterName,
                parameter.getDescription(),
                prefix,
                locale);
        String lpattern =
            getParameterPattern(
                i18nProvider, bundle, uid, parameterName, parameter.getPattern(), prefix, locale);
        List<ParameterOption> loptions =
            getLocalizedOptions(
                i18nProvider, parameter.getOptions(), bundle, uid, parameterName, prefix, locale);
        String lunitLabel =
            getUnitLabel(
                i18nProvider, bundle, uid, parameterName, parameter.getUnitLabel(), prefix, locale);

        configDescriptions.add(
            ConfigDescriptionParameterBuilder.create(parameterName, parameter.getType())
                .withMinimum(parameter.getMinimum())
                .withMaximum(parameter.getMaximum())
                .withStepSize(parameter.getStepSize())
                .withPattern(lpattern)
                .withRequired(parameter.isRequired())
                .withMultiple(parameter.isMultiple())
                .withReadOnly(parameter.isReadOnly())
                .withContext(parameter.getContext())
                .withDefault(parameter.getDefault())
                .withLabel(llabel)
                .withDescription(ldescription)
                .withFilterCriteria(parameter.getFilterCriteria())
                .withGroupName(parameter.getGroupName())
                .withAdvanced(parameter.isAdvanced())
                .withOptions(loptions)
                .withLimitToOptions(parameter.getLimitToOptions())
                .withMultipleLimit(parameter.getMultipleLimit())
                .withUnit(parameter.getUnit())
                .withUnitLabel(lunitLabel)
                .build());
      }
    }
    return configDescriptions;
  }
    @Override
    public ConfigDescription getConfigDescription(URI uri, Locale locale) {
        if (uri == null) {
            return null;
        }

        if ("thing".equals(uri.getScheme()) == false) {
            return null;
        }

        ThingUID thingUID = new ThingUID(uri.getSchemeSpecificPart());
        ThingType thingType = thingTypeRegistry.getThingType(thingUID.getThingTypeUID());
        if (thingType == null) {
            return null;
        }

        // Is this a zwave thing?
        if (!thingUID.getBindingId().equals(ZWaveBindingConstants.BINDING_ID)) {
            return null;
        }

        // And make sure this is a node because we want to get the id off the end...
        if (!thingUID.getId().startsWith("node")) {
            return null;
        }
        int nodeId = Integer.parseInt(thingUID.getId().substring(4));

        Thing thing = getThing(thingUID);
        if (thing == null) {
            return null;
        }
        ThingUID bridgeUID = thing.getBridgeUID();

        // Get the controller for this thing
        Thing bridge = getThing(bridgeUID);
        if (bridge == null) {
            return null;
        }

        // Get its handler and node
        ZWaveControllerHandler handler = (ZWaveControllerHandler) bridge.getHandler();
        ZWaveNode node = handler.getNode(nodeId);

        List<ConfigDescriptionParameterGroup> groups = new ArrayList<ConfigDescriptionParameterGroup>();
        List<ConfigDescriptionParameter> parameters = new ArrayList<ConfigDescriptionParameter>();

        groups.add(new ConfigDescriptionParameterGroup("actions", "", false, "Actions", null));
        groups.add(new ConfigDescriptionParameterGroup("thingcfg", "home", false, "Device Configuration", null));

        parameters.add(ConfigDescriptionParameterBuilder
                .create(ZWaveBindingConstants.CONFIGURATION_POLLPERIOD, Type.INTEGER).withLabel("Polling Period")
                .withDescription("Set the minimum polling period for this device<BR/>"
                        + "Note that the polling period may be longer than set since the binding treats "
                        + "polls as the lowest priority data within the network.")
                .withDefault("1800").withGroupName("thingcfg").build());

        // If we support the wakeup class, then add the configuration
        if (node.getCommandClass(ZWaveCommandClass.CommandClass.WAKE_UP) != null) {
            groups.add(new ConfigDescriptionParameterGroup("wakeup", "sleep", false, "Wakeup Configuration", null));

            parameters.add(ConfigDescriptionParameterBuilder
                    .create(ZWaveBindingConstants.CONFIGURATION_WAKEUPINTERVAL, Type.TEXT).withLabel("Wakeup Interval")
                    .withDescription("Sets the number of seconds that the device will wakeup<BR/>"
                            + "Setting a shorter time will allow openHAB to configure the device more regularly, but may use more battery power.<BR>"
                            + "<B>Note:</B> This setting does not impact device notifications such as alarms.")
                    .withDefault("").withGroupName("wakeup").build());

            parameters.add(
                    ConfigDescriptionParameterBuilder.create(ZWaveBindingConstants.CONFIGURATION_WAKEUPNODE, Type.TEXT)
                            .withLabel("Wakeup Node").withAdvanced(true)
                            .withDescription("Sets the wakeup node to which the device will send notifications.<BR/>"
                                    + "This should normally be set to the openHAB controller - "
                                    + "if it isn't, openHAB will not receive notifications when the device wakes up, "
                                    + "and will not be able to configure the device.")
                            .withDefault("").withGroupName("wakeup").build());
        }

        // If we support the node name class, then add the configuration
        if (node.getCommandClass(ZWaveCommandClass.CommandClass.NODE_NAMING) != null) {
            parameters.add(
                    ConfigDescriptionParameterBuilder.create(ZWaveBindingConstants.CONFIGURATION_NODENAME, Type.TEXT)
                            .withLabel("Node Name").withDescription("Sets a string for the device name")
                            .withGroupName("thingcfg").withDefault("").build());
            parameters.add(ConfigDescriptionParameterBuilder
                    .create(ZWaveBindingConstants.CONFIGURATION_NODELOCATION, Type.TEXT)
                    .withDescription("Sets a string for the device location").withLabel("Node Location").withDefault("")
                    .withGroupName("thingcfg").build());
        }

        // If we support the switch_all class, then add the configuration
        if (node.getCommandClass(ZWaveCommandClass.CommandClass.SWITCH_ALL) != null) {
            List<ParameterOption> options = new ArrayList<ParameterOption>();
            options.add(new ParameterOption("0", "Exclude from All On and All Off groups"));
            options.add(new ParameterOption("1", "Include in All On group"));
            options.add(new ParameterOption("2", "Include in All Off group"));
            options.add(new ParameterOption("255", "Include in All On and All Off groups"));
            parameters.add(ConfigDescriptionParameterBuilder
                    .create(ZWaveBindingConstants.CONFIGURATION_SWITCHALLMODE, Type.TEXT).withLabel("Switch All Mode")
                    .withDescription("Set the mode for the switch when receiving SWITCH ALL commands.").withDefault("0")
                    .withGroupName("thingcfg").withOptions(options).build());
        }

        // If we support DOOR_LOCK - add options
        if (node.getCommandClass(ZWaveCommandClass.CommandClass.DOOR_LOCK) != null) {
            parameters.add(ConfigDescriptionParameterBuilder
                    .create(ZWaveBindingConstants.CONFIGURATION_DOORLOCKTIMEOUT, Type.TEXT).withLabel("Lock Timeout")
                    .withDescription("Set the timeout on the lock.").withDefault("30").withGroupName("thingcfg")
                    .build());
        }

        ZWaveUserCodeCommandClass userCodeClass = (ZWaveUserCodeCommandClass) node
                .getCommandClass(ZWaveCommandClass.CommandClass.USER_CODE);
        if (userCodeClass != null && userCodeClass.getNumberOfSupportedCodes() > 0) {
            groups.add(new ConfigDescriptionParameterGroup("usercode", "lock", false, "User Code", null));

            for (int code = 1; code <= userCodeClass.getNumberOfSupportedCodes(); code++) {
                parameters.add(ConfigDescriptionParameterBuilder
                        .create(ZWaveBindingConstants.CONFIGURATION_USERCODE + code, Type.TEXT)
                        .withLabel("Code " + code).withDescription("Set the user code (4 to 10 numbers)")
                        .withDefault("").withGroupName("usercode").build());
            }
        }

        List<ParameterOption> options = new ArrayList<ParameterOption>();
        options.add(new ParameterOption(ZWaveBindingConstants.ACTION_CHECK_VALUE.toString(), "Do"));
        if (node.isInitializationComplete() == true) {
            parameters.add(ConfigDescriptionParameterBuilder.create("action_reinit", Type.INTEGER)
                    .withLabel("Reinitialise the device").withAdvanced(true).withOptions(options).withDefault("-232323")
                    .withGroupName("actions").build());
>>>>>>> Z-Wave Updates
        if (node.isInitializationComplete() == true) {
            parameters.add(ConfigDescriptionParameterBuilder.create("action_reinit", Type.TEXT)
                    .withLabel("Reinitialise the device").withAdvanced(true).withDefault("GO").withGroupName("actions")
                    .build());
=======
 } else {
     // Otherwise, allow us to put this on the failed list
     parameters.add(ConfigDescriptionParameterBuilder.create("action_failed", Type.TEXT)
             .withLabel("Set device as FAILed").withAdvanced(true).withDefault("GO").withGroupName("actions")
             .build());
 }
 if (node.getNodeState() == ZWaveNodeState.FAILED) {
     parameters.add(ConfigDescriptionParameterBuilder.create("action_remove", Type.TEXT)
             .withLabel("Remove device from controller").withAdvanced(true).withDefault("GO")
             .withGroupName("actions").build());
 } else {