git.basschouten.com Git - openhab-addons.git/blob

   1 /**
   2  * Copyright (c) 2010-2020 Contributors to the openHAB project
   3  *
   4  * See the NOTICE file(s) distributed with this work for additional
   5  * information.
   6  *
   7  * This program and the accompanying materials are made available under the
   8  * terms of the Eclipse Public License 2.0 which is available at
   9  * http://www.eclipse.org/legal/epl-2.0
  10  *
  11  * SPDX-License-Identifier: EPL-2.0
  12  */
  13 package org.openhab.binding.tacmi.internal.schema;
  14
  15 import java.math.BigDecimal;
  16 import java.net.URI;
  17 import java.util.ArrayList;
  18 import java.util.HashSet;
  19 import java.util.List;
  20 import java.util.Map;
  21 import java.util.Map.Entry;
  22 import java.util.Set;
  23 import java.util.concurrent.ExecutionException;
  24 import java.util.concurrent.TimeoutException;
  25
  26 import org.attoparser.ParseException;
  27 import org.attoparser.simple.AbstractSimpleMarkupHandler;
  28 import org.eclipse.jdt.annotation.NonNullByDefault;
  29 import org.eclipse.jdt.annotation.Nullable;
  30 import org.eclipse.jetty.util.StringUtil;
  31 import org.openhab.binding.tacmi.internal.TACmiBindingConstants;
  32 import org.openhab.binding.tacmi.internal.TACmiChannelTypeProvider;
  33 import org.openhab.binding.tacmi.internal.schema.ApiPageEntry.Type;
  34 import org.openhab.core.library.types.DecimalType;
  35 import org.openhab.core.library.types.OnOffType;
  36 import org.openhab.core.library.types.QuantityType;
  37 import org.openhab.core.library.types.StringType;
  38 import org.openhab.core.library.unit.SIUnits;
  39 import org.openhab.core.library.unit.SmartHomeUnits;
  40 import org.openhab.core.thing.Channel;
  41 import org.openhab.core.thing.ChannelUID;
  42 import org.openhab.core.thing.binding.builder.ChannelBuilder;
  43 import org.openhab.core.thing.type.ChannelType;
  44 import org.openhab.core.thing.type.ChannelTypeBuilder;
  45 import org.openhab.core.thing.type.ChannelTypeUID;
  46 import org.openhab.core.types.State;
  47 import org.openhab.core.types.StateDescriptionFragmentBuilder;
  48 import org.openhab.core.types.StateOption;
  49 import org.slf4j.Logger;
  50 import org.slf4j.LoggerFactory;
  51
  52 /**
  53  * The {@link ApiPageParser} class parses the 'API' schema page from the CMI and
  54  * maps it to our channels
  55  *
  56  * @author Christian Niessner - Initial contribution
  57  */
  58 @NonNullByDefault
  59 public class ApiPageParser extends AbstractSimpleMarkupHandler {
  60
  61     private final Logger logger = LoggerFactory.getLogger(ApiPageParser.class);
  62
  63     static enum ParserState {
  64         INIT,
  65         DATA_ENTRY
  66     }
  67
  68     static enum FieldType {
  69         UNKNOWN,
  70         READ_ONLY,
  71         FORM_VALUE,
  72         BUTTON,
  73         IGNORE
  74     }
  75
  76     static enum ButtonValue {
  77         UNKNOWN,
  78         ON,
  79         OFF
  80     }
  81
  82     private ParserState parserState = ParserState.INIT;
  83     private TACmiSchemaHandler taCmiSchemaHandler;
  84     private TACmiChannelTypeProvider channelTypeProvider;
  85     private boolean configChanged = false;
  86     private FieldType fieldType = FieldType.UNKNOWN;
  87     private @Nullable String id;
  88     private @Nullable String address;
  89     private @Nullable StringBuilder value;
  90     private ButtonValue buttonValue = ButtonValue.UNKNOWN;
  91     private Map<String, @Nullable ApiPageEntry> entries;
  92     private Set<String> seenNames = new HashSet<>();
  93     private List<Channel> channels = new ArrayList<>();
  94
  95     public ApiPageParser(TACmiSchemaHandler taCmiSchemaHandler, Map<String, @Nullable ApiPageEntry> entries,
  96             TACmiChannelTypeProvider channelTypeProvider) {
  97         super();
  98         this.taCmiSchemaHandler = taCmiSchemaHandler;
  99         this.entries = entries;
 100         this.channelTypeProvider = channelTypeProvider;
 101     }
 102
 103     @Override
 104     public void handleDocumentStart(final long startTimeNanos, final int line, final int col) throws ParseException {
 105         this.parserState = ParserState.INIT;
 106         this.seenNames.clear();
 107         this.channels.clear();
 108     }
 109
 110     @Override
 111     public void handleDocumentEnd(final long endTimeNanos, final long totalTimeNanos, final int line, final int col)
 112             throws ParseException {
 113         if (this.parserState != ParserState.INIT) {
 114             logger.debug("Parserstate == Init expected, but is {}", this.parserState);
 115         }
 116     }
 117
 118     @Override
 119     @NonNullByDefault({})
 120     public void handleStandaloneElement(final @Nullable String elementName,
 121             final @Nullable Map<String, String> attributes, final boolean minimized, final int line, final int col)
 122             throws ParseException {
 123
 124         logger.debug("Unexpected StandaloneElement in {}:{}: {} [{}]", line, col, elementName, attributes);
 125     }
 126
 127     @Override
 128     @NonNullByDefault({})
 129     public void handleOpenElement(final @Nullable String elementName, final @Nullable Map<String, String> attributes,
 130             final int line, final int col) throws ParseException {
 131
 132         if (this.parserState == ParserState.INIT && "div".equals(elementName)) {
 133             this.parserState = ParserState.DATA_ENTRY;
 134             String classFlags;
 135             if (attributes == null) {
 136                 classFlags = null;
 137                 this.id = null;
 138                 this.address = null;
 139             } else {
 140                 this.id = attributes.get("id");
 141                 this.address = attributes.get("adresse");
 142                 classFlags = attributes.get("class");
 143             }
 144             this.fieldType = FieldType.READ_ONLY;
 145             this.value = new StringBuilder();
 146             this.buttonValue = ButtonValue.UNKNOWN;
 147             if (classFlags != null && StringUtil.isNotBlank(classFlags)) {
 148                 String[] classFlagList = classFlags.split("[ \n\r]");
 149                 for (String classFlag : classFlagList) {
 150                     if ("changex2".equals(classFlag)) {
 151                         this.fieldType = FieldType.FORM_VALUE;
 152                     } else if ("buttonx2".equals(classFlag) || "taster".equals(classFlag)) {
 153                         this.fieldType = FieldType.BUTTON;
 154                     } else if ("visible0".equals(classFlag)) {
 155                         this.buttonValue = ButtonValue.OFF;
 156                     } else if ("visible1".equals(classFlag)) {
 157                         this.buttonValue = ButtonValue.ON;
 158                     } else if ("durchsichtig".equals(classFlag)) { // link
 159                         this.fieldType = FieldType.IGNORE;
 160                     } else if ("bord".equals(classFlag)) { // special button style - not of our interest...
 161                     } else {
 162                         logger.debug("Unhanndled class in {}:{}:{}: '{}' ", id, line, col, classFlag);
 163                     }
 164                 }
 165             }
 166         } else if (this.parserState == ParserState.DATA_ENTRY && this.fieldType == FieldType.BUTTON
 167                 && "span".equals(elementName)) {
 168             // ignored...
 169         } else {
 170             logger.debug("Unexpected OpenElement in {}:{}: {} [{}]", line, col, elementName, attributes);
 171         }
 172     }
 173
 174     @Override
 175     public void handleCloseElement(final @Nullable String elementName, final int line, final int col)
 176             throws ParseException {
 177         if (this.parserState == ParserState.DATA_ENTRY && "div".equals(elementName)) {
 178             this.parserState = ParserState.INIT;
 179             StringBuilder sb = this.value;
 180             this.value = null;
 181             if (sb != null) {
 182                 while (sb.length() > 0 && sb.charAt(0) == ' ') {
 183                     sb = sb.delete(0, 0);
 184                 }
 185                 if (this.fieldType == FieldType.READ_ONLY || this.fieldType == FieldType.FORM_VALUE) {
 186                     int lids = sb.lastIndexOf(":");
 187                     int fsp = sb.indexOf(" ");
 188                     if (fsp < 0 || lids < 0 || fsp > lids) {
 189                         logger.debug("Invalid format for setting {}:{}:{} [{}] : {}", id, line, col, this.fieldType,
 190                                 sb);
 191                     } else {
 192                         String shortName = sb.substring(0, fsp).trim();
 193                         String description = sb.substring(fsp + 1, lids).trim();
 194                         String value = sb.substring(lids + 1).trim();
 195                         getApiPageEntry(id, line, col, shortName, description, value);
 196                     }
 197                 } else if (this.fieldType == FieldType.BUTTON) {
 198                     String sbt = sb.toString().trim().replaceAll("[\r\n ]+", " ");
 199                     int fsp = sbt.indexOf(" ");
 200
 201                     if (fsp < 0) {
 202                         logger.debug("Invalid format for setting {}:{}:{} [{}] : {}", id, line, col, this.fieldType,
 203                                 sbt);
 204                     } else {
 205                         String shortName = sbt.substring(0, fsp).trim();
 206                         String description = sbt.substring(fsp + 1).trim();
 207                         getApiPageEntry(id, line, col, shortName, description, this.buttonValue);
 208                     }
 209                 } else if (this.fieldType == FieldType.IGNORE) {
 210                     // ignore
 211                 } else {
 212                     logger.debug("Unhandled setting {}:{}:{} [{}] : {}", id, line, col, this.fieldType, sb);
 213                 }
 214             }
 215         } else if (this.parserState == ParserState.DATA_ENTRY && this.fieldType == FieldType.BUTTON
 216                 && "span".equals(elementName)) {
 217             // ignored...
 218         } else {
 219             logger.debug("Unexpected CloseElement in {}:{}: {}", line, col, elementName);
 220         }
 221     }
 222
 223     @Override
 224     public void handleAutoCloseElement(final @Nullable String elementName, final int line, final int col)
 225             throws ParseException {
 226         logger.debug("Unexpected AutoCloseElement in {}:{}: {}", line, col, elementName);
 227     }
 228
 229     @Override
 230     public void handleUnmatchedCloseElement(final @Nullable String elementName, final int line, final int col)
 231             throws ParseException {
 232         logger.debug("Unexpected UnmatchedCloseElement in {}:{}: {}", line, col, elementName);
 233     }
 234
 235     @Override
 236     public void handleDocType(final @Nullable String elementName, final @Nullable String publicId,
 237             final @Nullable String systemId, final @Nullable String internalSubset, final int line, final int col)
 238             throws ParseException {
 239         logger.debug("Unexpected DocType in {}:{}: {}/{}/{}/{}", line, col, elementName, publicId, systemId,
 240                 internalSubset);
 241     }
 242
 243     @Override
 244     public void handleComment(final char @Nullable [] buffer, final int offset, final int len, final int line,
 245             final int col) throws ParseException {
 246         logger.debug("Unexpected comment in {}:{}: {}", line, col, new String(buffer, offset, len));
 247     }
 248
 249     @Override
 250     public void handleCDATASection(final char @Nullable [] buffer, final int offset, final int len, final int line,
 251             final int col) throws ParseException {
 252         logger.debug("Unexpected CDATA in {}:{}: {}", line, col, new String(buffer, offset, len));
 253     }
 254
 255     @Override
 256     public void handleText(final char @Nullable [] buffer, final int offset, final int len, final int line,
 257             final int col) throws ParseException {
 258
 259         if (buffer == null) {
 260             return;
 261         }
 262
 263         if (this.parserState == ParserState.DATA_ENTRY) {
 264             // we append it to our current value
 265             StringBuilder sb = this.value;
 266             if (sb != null) {
 267                 sb.append(buffer, offset, len);
 268             }
 269         } else if (this.parserState == ParserState.INIT && ((len == 1 && buffer[offset] == '\n')
 270                 || (len == 2 && buffer[offset] == '\r' && buffer[offset + 1] == '\n'))) {
 271             // single newline - ignore/drop it...
 272         } else {
 273             String msg = new String(buffer, offset, len).replace("\n", "\\n").replace("\r", "\\r");
 274             logger.debug("Unexpected Text {}:{}: ParserState: {} ({}) `{}`", line, col, parserState, len, msg);
 275         }
 276     }
 277
 278     @Override
 279     public void handleXmlDeclaration(final @Nullable String version, final @Nullable String encoding,
 280             final @Nullable String standalone, final int line, final int col) throws ParseException {
 281         logger.debug("Unexpected XML Declaration {}:{}: {} {} {}", line, col, version, encoding, standalone);
 282     }
 283
 284     @Override
 285     public void handleProcessingInstruction(final @Nullable String target, final @Nullable String content,
 286             final int line, final int col) throws ParseException {
 287         logger.debug("Unexpected ProcessingInstruction {}:{}: {} {}", line, col, target, content);
 288     }
 289
 290     private void getApiPageEntry(@Nullable String id2, int line, int col, String shortName, String description,
 291             Object value) {
 292         if (logger.isDebugEnabled()) {
 293             logger.debug("Found parameter {}:{}:{} [{}] : {} \"{}\" = {}", id, line, col, this.fieldType, shortName,
 294                     description, value);
 295         }
 296         if (!this.seenNames.add(shortName)) {
 297             logger.warn("Found duplicate parameter '{}' in {}:{}:{} [{}] : {} \"{}\" = {}", shortName, id, line, col,
 298                     this.fieldType, shortName, description, value);
 299             return;
 300         }
 301
 302         if (value instanceof String && ((String) value).contains("can_busy")) {
 303             return; // special state to indicate value currently cannot be retrieved..
 304         }
 305         ApiPageEntry.Type type;
 306         State state;
 307         String channelType;
 308         ChannelTypeUID ctuid;
 309         switch (this.fieldType) {
 310             case BUTTON:
 311                 type = Type.SWITCH_BUTTON;
 312                 state = this.buttonValue == ButtonValue.ON ? OnOffType.ON : OnOffType.OFF;
 313                 ctuid = TACmiBindingConstants.CHANNEL_TYPE_SCHEME_SWITCH_RW_UID;
 314                 channelType = "Switch";
 315                 break;
 316             case READ_ONLY:
 317             case FORM_VALUE:
 318                 String vs = (String) value;
 319                 boolean isOn = "ON".equals(vs) || "EIN".equals(vs); // C.M.I. mixes up languages...
 320                 if (isOn || "OFF".equals(vs) || "AUS".equals(vs)) {
 321                     channelType = "Switch";
 322                     state = isOn ? OnOffType.ON : OnOffType.OFF;
 323                     if (this.fieldType == FieldType.READ_ONLY || this.address == null) {
 324                         ctuid = TACmiBindingConstants.CHANNEL_TYPE_SCHEME_SWITCH_RO_UID;
 325                         type = Type.READ_ONLY_SWITCH;
 326                     } else {
 327                         ctuid = TACmiBindingConstants.CHANNEL_TYPE_SCHEME_SWITCH_RW_UID;
 328                         type = Type.SWITCH_FORM;
 329                     }
 330                 } else {
 331                     try {
 332                         // check if we have a numeric value (either with or without unit)
 333                         String[] valParts = vs.split(" ");
 334                         // It seems for some wired cases the C.M.I. uses different decimal separators for
 335                         // different device types. It seems all 'new' X2-Devices use a dot as separator,
 336                         // for the older pre-X2 devices (i.e. the UVR 1611) we get a comma. So we
 337                         // we replace all ',' with '.' to check if it's a valid number...
 338                         String val = valParts[0].replace(',', '.');
 339                         BigDecimal bd = new BigDecimal(val);
 340                         if (valParts.length == 2) {
 341                             if ("°C".equals(valParts[1])) {
 342                                 channelType = "Number:Temperature";
 343                                 state = new QuantityType<>(bd, SIUnits.CELSIUS);
 344                             } else if ("%".equals(valParts[1])) {
 345                                 channelType = "Number:Percent";
 346                                 state = new QuantityType<>(bd, SmartHomeUnits.PERCENT);
 347                             } else if ("Imp".equals(valParts[1])) {
 348                                 // impulses - no idea how to map this to something useful here?
 349                                 channelType = "Number";
 350                                 state = new DecimalType(bd);
 351                             } else if ("V".equals(valParts[1])) {
 352                                 channelType = "Number:Voltage";
 353                                 state = new QuantityType<>(bd, SmartHomeUnits.VOLT);
 354                             } else if ("A".equals(valParts[1])) {
 355                                 channelType = "Number:Current";
 356                                 state = new QuantityType<>(bd, SmartHomeUnits.AMPERE);
 357                             } else if ("Hz".equals(valParts[1])) {
 358                                 channelType = "Number:Frequency";
 359                                 state = new QuantityType<>(bd, SmartHomeUnits.HERTZ);
 360                             } else if ("kW".equals(valParts[1])) {
 361                                 channelType = "Number:Power";
 362                                 bd = bd.multiply(new BigDecimal(1000));
 363                                 state = new QuantityType<>(bd, SmartHomeUnits.WATT);
 364                             } else if ("kWh".equals(valParts[1])) {
 365                                 channelType = "Number:Power";
 366                                 bd = bd.multiply(new BigDecimal(1000));
 367                                 state = new QuantityType<>(bd, SmartHomeUnits.KILOWATT_HOUR);
 368                             } else if ("l/h".equals(valParts[1])) {
 369                                 channelType = "Number:Volume";
 370                                 bd = bd.divide(new BigDecimal(60));
 371                                 state = new QuantityType<>(bd, SmartHomeUnits.LITRE_PER_MINUTE);
 372                             } else {
 373                                 channelType = "Number";
 374                                 state = new DecimalType(bd);
 375                                 logger.debug("Unhandled UoM for channel {} of type {} for '{}': {}", shortName,
 376                                         channelType, description, valParts[1]);
 377                             }
 378                         } else {
 379                             channelType = "Number";
 380                             state = new DecimalType(bd);
 381                         }
 382                         if (this.fieldType == FieldType.READ_ONLY || this.address == null) {
 383                             ctuid = TACmiBindingConstants.CHANNEL_TYPE_SCHEME_NUMERIC_RO_UID;
 384                             type = Type.READ_ONLY_NUMERIC;
 385                         } else {
 386                             ctuid = null;
 387                             type = Type.NUMERIC_FORM;
 388                         }
 389                     } catch (NumberFormatException nfe) {
 390                         // not a number...
 391                         channelType = "String";
 392                         if (this.fieldType == FieldType.READ_ONLY || this.address == null) {
 393                             ctuid = TACmiBindingConstants.CHANNEL_TYPE_SCHEME_STATE_RO_UID;
 394                             type = Type.READ_ONLY_STATE;
 395                         } else {
 396                             ctuid = null;
 397                             type = Type.STATE_FORM;
 398                         }
 399                         state = new StringType(vs);
 400                     }
 401                 }
 402                 break;
 403             case UNKNOWN:
 404             case IGNORE:
 405                 return;
 406             default:
 407                 // should't happen but we have to add default for the compiler...
 408                 return;
 409         }
 410         ApiPageEntry e = this.entries.get(shortName);
 411         if (e == null || e.type != type || !channelType.equals(e.channel.getAcceptedItemType())) {
 412             @Nullable
 413             Channel channel = this.taCmiSchemaHandler.getThing().getChannel(shortName);
 414             @Nullable
 415             ChangerX2Entry cx2e = null;
 416             if (this.fieldType == FieldType.FORM_VALUE) {
 417                 try {
 418                     URI uri = this.taCmiSchemaHandler.buildUri("INCLUDE/changerx2.cgi?sadrx2=" + address);
 419                     final ChangerX2Parser pp = this.taCmiSchemaHandler.parsePage(uri, new ChangerX2Parser(shortName));
 420                     cx2e = pp.getParsedEntry();
 421                 } catch (final ParseException | RuntimeException ex) {
 422                     logger.warn("Error parsing API Scheme: {} ", ex.getMessage(), ex);
 423                 } catch (final TimeoutException | InterruptedException | ExecutionException ex) {
 424                     logger.warn("Error loading API Scheme: {} ", ex.getMessage());
 425                 }
 426             }
 427             if (channel == null) {
 428                 logger.debug("Creating / updating channel {} of type {} for '{}'", shortName, channelType, description);
 429                 this.configChanged = true;
 430                 ChannelUID channelUID = new ChannelUID(this.taCmiSchemaHandler.getThing().getUID(), shortName);
 431                 ChannelBuilder channelBuilder = ChannelBuilder.create(channelUID, channelType);
 432                 channelBuilder.withLabel(description);
 433                 if (ctuid != null) {
 434                     channelBuilder.withType(ctuid);
 435                 } else if (cx2e != null) {
 436                     StateDescriptionFragmentBuilder sdb = StateDescriptionFragmentBuilder.create()
 437                             .withReadOnly(type.readOnly);
 438                     String itemType;
 439                     switch (cx2e.optionType) {
 440                         case NUMBER:
 441                             itemType = "Number";
 442                             String min = cx2e.options.get(ChangerX2Entry.NUMBER_MIN);
 443                             if (min != null && !min.trim().isEmpty()) {
 444                                 sdb.withMinimum(new BigDecimal(min));
 445                             }
 446                             String max = cx2e.options.get(ChangerX2Entry.NUMBER_MAX);
 447                             if (max != null && !max.trim().isEmpty()) {
 448                                 sdb.withMaximum(new BigDecimal(max));
 449                             }
 450                             String step = cx2e.options.get(ChangerX2Entry.NUMBER_STEP);
 451                             if (step != null && !step.trim().isEmpty()) {
 452                                 sdb.withStep(new BigDecimal(step));
 453                             }
 454                             break;
 455                         case SELECT:
 456                             itemType = "String";
 457                             for (Entry<String, @Nullable String> entry : cx2e.options.entrySet()) {
 458                                 String val = entry.getValue();
 459                                 if (val != null) {
 460                                     sdb.withOption(new StateOption(val, entry.getKey()));
 461                                 }
 462                             }
 463                             break;
 464                         default:
 465                             throw new IllegalStateException();
 466                     }
 467                     ChannelType ct = ChannelTypeBuilder
 468                             .state(new ChannelTypeUID(TACmiBindingConstants.BINDING_ID, shortName), shortName, itemType)
 469                             .withDescription("Auto-created for " + shortName)
 470                             .withStateDescription(sdb.build().toStateDescription()).build();
 471                     channelTypeProvider.addChannelType(ct);
 472                     channelBuilder.withType(ct.getUID());
 473                 } else {
 474                     logger.warn("Error configurating channel for {}: channeltype cannot be determined!", shortName);
 475                 }
 476                 channel = channelBuilder.build(); // add configuration property...
 477             }
 478             this.configChanged = true;
 479             e = new ApiPageEntry(type, channel, address, cx2e, state);
 480             this.entries.put(shortName, e);
 481         }
 482         this.channels.add(e.channel);
 483         e.setLastState(state);
 484         this.taCmiSchemaHandler.updateState(e.channel.getUID(), state);
 485     }
 486
 487     protected boolean isConfigChanged() {
 488         return this.configChanged;
 489     }
 490
 491     protected List<Channel> getChannels() {
 492         return channels;
 493     }
 494 }