iobroker.loxone 3.0.0 → 4.0.0

package/src/structure-file.d.ts

@@ -0,0 +1,154 @@
+/* eslint-disable jsdoc/require-jsdoc */
+
+export interface StructureFile {
+    lastModified: string;
+    msInfo: MSInfo;
+    globalStates: GlobalStates;
+    operatingModes: OperatingModes;
+    rooms: { [key: string]: Room };
+    cats: { [key: string]: CatValue };
+    controls: { [key: string]: Control };
+    weatherServer: WeatherServer;
+    times: { [key: string]: FieldType };
+    mediaServer: { [key: string]: MediaServer };
+    autopilot: { [key: string]: Autopilot };
+    messageCenter: MessageCenter;
+}
+
+export interface MSInfo {
+    serialNr: string;
+    msName: string;
+    projectName: string;
+    localUrl: string;
+    remoteUrl: string;
+    tempUnit: number;
+    currency: string;
+    squareMeasure: string;
+    location: string;
+    languageCode: string;
+    heatPeriodStart: string;
+    heatPeriodEnd: string;
+    coolPeriodStart: string;
+    coolPeriodEnd: string;
+    catTitle: string;
+    roomTitle: string;
+    miniserverType: number;
+    deviceMonitor: string;
+    currentUser: CurrentUser;
+}
+
+export type GlobalStates = { [key: string]: string };
+
+export type OperatingModes = { [key: string]: string };
+
+export type Controls = { [key: string]: Control };
+
+export interface CurrentUser {
+    name: string;
+    uuid: string;
+    isAdmin: boolean;
+    changePassword: boolean;
+    userRights: number;
+}
+
+export interface CatValue {
+    uuid: string;
+    name: string;
+    image: string;
+    defaultRating: number;
+    isFavorite: boolean;
+    type: string;
+    color: string;
+}
+
+export interface Room {
+    uuid: string;
+    name: string;
+    image: string;
+    defaultRating: number;
+    isFavorite: boolean;
+    type: number;
+}
+
+export interface FieldType {
+    id: number;
+    name: string;
+    analog: boolean;
+    format?: string;
+    unit?: string;
+}
+
+export interface WeatherServer {
+    states: WeatherServerStates;
+    format: Format;
+    weatherTypeTexts: { [key: string]: string };
+    weatherFieldTypes: { [key: string]: FieldType };
+}
+
+export interface Format {
+    relativeHumidity: string;
+    temperature: string;
+    windSpeed: string;
+    precipitation: string;
+    barometricPressure: string;
+}
+
+export interface WeatherServerStates {
+    actual: string;
+    forecast: string;
+}
+
+export interface MediaServer {
+    name: string;
+    type: number;
+    host: string;
+    mac: string;
+    uuidAction: string;
+    useTriggerCard: boolean;
+    states: MediaServerStates;
+}
+
+export interface MediaServerStates {
+    audioEvents: string;
+    apiVersion: string;
+    serverState: string;
+    grouping: string;
+    connState: string;
+}
+
+export interface Autopilot {
+    name: string;
+    uuidAction: string;
+    states: AutopilotStates;
+}
+
+export interface AutopilotStates {
+    changed: string;
+    history: string;
+}
+
+export interface MessageCenter {
+    name: string;
+    uuidAction: string;
+    states: MessageCenterStates;
+}
+
+export interface MessageCenterStates {
+    changed: string;
+}
+
+export interface Control {
+    name: string;
+    type: string;
+    uuidAction: string;
+    room: string;
+    cat: string;
+    defaultRating: number;
+    isFavorite: boolean;
+    isSecured: boolean;
+    details: { [key: string]: unknown };
+    states: ControlStates;
+    subControls?: Controls;
+}
+
+export type ControlStates = { [key: string]: string };

package/src/weather-server-handler.ts

@@ -0,0 +1,266 @@
+import { sprintf } from 'sprintf-js';
+import { LoxoneHandlerBase } from './loxone-handler-base';
+import type { Loxone } from './main';
+import type { Format, WeatherServer } from './structure-file';
+
+/**
+ * Handler for Weather Server information.
+ */
+export class WeatherServerHandler extends LoxoneHandlerBase {
+    private readonly deviceName = 'WeatherServer';
+    private format!: Format;
+    private weatherTypeTexts: Record<string, string> = {};
+    private forecastChannelsCount = 0;
+
+    /**
+     * Creates an instance of WeatherServerHandler.
+     *
+     * @param adapter The Loxone adapter instance.
+     */
+    public constructor(protected readonly adapter: Loxone) {
+        super(adapter);
+    }
+
+    /**
+     * Loads the weather server data and sets up state objects and event handlers.
+     *
+     * @param data The WeatherServer data from the structure file.
+     * @param filter The filter for forecast data ('current', '1day', or 'all').
+     * @returns A promise that resolves when loading is complete.
+     */
+    public async loadAsync(data: WeatherServer, filter: 'current' | '1day' | 'all'): Promise<void> {
+        if (data === undefined || !('states' in data) || !('actual' in data.states)) {
+            return;
+        }
+
+        this.format = data.format;
+        this.weatherTypeTexts = data.weatherTypeTexts;
+
+        const deviceName = 'WeatherServer';
+        await this.updateObjectAsync(deviceName, {
+            type: 'device',
+            common: {
+                name: deviceName,
+                role: 'weather',
+            },
+            native: { data: data as any },
+        });
+
+        await this.setWeatherObjectsAsync('Actual');
+
+        this.addStateEventHandler(data.states.actual, async (value: any) => {
+            await this.setWeatherStates(`${deviceName}.Actual`, value.entries[0]);
+        });
+
+        if (filter === 'current') {
+            return;
+        }
+
+        this.addStateEventHandler(data.states.forecast, async (value: any) => {
+            const hourCount = Math.min(value.entries.length, filter === '1day' ? 24 : Number.MAX_VALUE);
+            for (let i = 0; i < hourCount; i++) {
+                const channelName = `Hour${sprintf('%02d', i + 1)}`;
+                if (i >= this.forecastChannelsCount) {
+                    await this.setWeatherObjectsAsync(channelName);
+                    this.forecastChannelsCount++;
+                }
+
+                await this.setWeatherStates(`${deviceName}.${channelName}`, value.entries[i]);
+            }
+        });
+    }
+
+    private async setWeatherStates(parent: string, values: any): Promise<void> {
+        if (values === undefined) {
+            return;
+        }
+
+        await this.setStateAck(`${parent}.barometricPressure`, values.barometricPressure);
+        await this.setFormattedStateAck(
+            `${parent}.barometricPressure-formatted`,
+            values.barometricPressure,
+            this.format.barometricPressure,
+        );
+        await this.setStateAck(`${parent}.dewPoint`, values.dewPoint);
+        await this.setFormattedStateAck(`${parent}.dewPoint-formatted`, values.dewPoint, this.format.temperature);
+        await this.setStateAck(`${parent}.perceivedTemperature`, values.perceivedTemperature);
+        await this.setFormattedStateAck(
+            `${parent}.perceivedTemperature-formatted`,
+            values.perceivedTemperature,
+            this.format.temperature,
+        );
+        await this.setStateAck(`${parent}.precipitation`, values.precipitation);
+        await this.setFormattedStateAck(
+            `${parent}.precipitation-formatted`,
+            values.precipitation,
+            this.format.precipitation,
+        );
+        await this.setStateAck(`${parent}.relativeHumidity`, values.relativeHumidity);
+        await this.setFormattedStateAck(
+            `${parent}.relativeHumidity-formatted`,
+            values.relativeHumidity,
+            this.format.relativeHumidity,
+        );
+        await this.setStateAck(`${parent}.solarRadiation`, values.solarRadiation);
+        await this.setStateAck(`${parent}.temperature`, values.temperature);
+        await this.setFormattedStateAck(`${parent}.temperature-formatted`, values.temperature, this.format.temperature);
+        await this.setTimeStateAck(`${parent}.timestamp`, values.timestamp);
+        await this.setStateAck(`${parent}.weatherType`, values.weatherType);
+        await this.setStateAck(`${parent}.weatherType-text`, this.weatherTypeTexts[values.weatherType]);
+        await this.setStateAck(`${parent}.windDirection`, values.windDirection);
+        await this.setStateAck(`${parent}.windSpeed`, values.windSpeed);
+        await this.setFormattedStateAck(`${parent}.windSpeed-formatted`, values.windSpeed, this.format.windSpeed);
+    }
+
+    private async setTimeStateAck(id: string, miniserverTime: number): Promise<void> {
+        const value = miniserverTime * 1000 + new Date(2009, 0, 1).getTime();
+        await this.setStateAck(id, value);
+    }
+
+    private async setWeatherObjectsAsync(channelName: string): Promise<void> {
+        await this.updateObjectAsync(`${this.deviceName}.${channelName}`, {
+            type: 'channel',
+            common: {
+                name: channelName,
+                role: 'weather.current',
+            },
+            native: {},
+        });
+
+        await this.setWeatherObjectAsync(
+            channelName,
+            'barometricPressure',
+            `${channelName}: Barometric pressure`,
+            'number',
+            'value',
+        );
+        await this.setWeatherObjectAsync(
+            channelName,
+            'barometricPressure-formatted',
+            `${channelName}: Barometric pressure: formatted`,
+            'string',
+            'text',
+        );
+        await this.setWeatherObjectAsync(
+            channelName,
+            'dewPoint',
+            `${channelName}: Dew point`,
+            'number',
+            'value.temperature',
+        );
+        await this.setWeatherObjectAsync(
+            channelName,
+            'dewPoint-formatted',
+            `${channelName}: Dew point: formatted`,
+            'string',
+            'text',
+        );
+        await this.setWeatherObjectAsync(
+            channelName,
+            'perceivedTemperature',
+            `${channelName}: Perceived temperature`,
+            'number',
+            'value.temperature',
+        );
+        await this.setWeatherObjectAsync(
+            channelName,
+            'perceivedTemperature-formatted',
+            `${channelName}: Perceived temperature: formatted`,
+            'string',
+            'text',
+        );
+        await this.setWeatherObjectAsync(
+            channelName,
+            'precipitation',
+            `${channelName}: Precipitation`,
+            'number',
+            'value',
+        );
+        await this.setWeatherObjectAsync(
+            channelName,
+            'precipitation-formatted',
+            `${channelName}: Precipitation: formatted`,
+            'string',
+            'text',
+        );
+        await this.setWeatherObjectAsync(
+            channelName,
+            'relativeHumidity',
+            `${channelName}: Relative humidity`,
+            'number',
+            'value.humidity',
+        );
+        await this.setWeatherObjectAsync(
+            channelName,
+            'relativeHumidity-formatted',
+            `${channelName}: Relative humidity: formatted`,
+            'string',
+            'text',
+        );
+        await this.setWeatherObjectAsync(
+            channelName,
+            'solarRadiation',
+            `${channelName}: Solar radiation`,
+            'number',
+            'value',
+        );
+        await this.setWeatherObjectAsync(
+            channelName,
+            'temperature',
+            `${channelName}: Temperature`,
+            'number',
+            'value.temperature',
+        );
+        await this.setWeatherObjectAsync(
+            channelName,
+            'temperature-formatted',
+            `${channelName}: Temperature: formatted`,
+            'string',
+            'text',
+        );
+        await this.setWeatherObjectAsync(channelName, 'timestamp', `${channelName}: Timestamp`, 'number', 'value.time');
+        await this.setWeatherObjectAsync(channelName, 'weatherType', `${channelName}: Weather type`, 'number', 'value');
+        await this.setWeatherObjectAsync(
+            channelName,
+            'weatherType-text',
+            `${channelName}: Weather type: text`,
+            'string',
+            'text',
+        );
+        await this.setWeatherObjectAsync(
+            channelName,
+            'windDirection',
+            `${channelName}: Wind direction`,
+            'number',
+            'value',
+        );
+        await this.setWeatherObjectAsync(channelName, 'windSpeed', `${channelName}: Wind speed`, 'number', 'value');
+        await this.setWeatherObjectAsync(
+            channelName,
+            'windSpeed-formatted',
+            `${channelName}: Wind speed: formatted`,
+            'string',
+            'text',
+        );
+    }
+
+    private async setWeatherObjectAsync(
+        channelName: string,
+        id: string,
+        name: string,
+        type: ioBroker.CommonType,
+        role: string,
+    ): Promise<void> {
+        await this.updateObjectAsync(`${this.deviceName}.${channelName}.${id}`, {
+            type: 'state',
+            common: {
+                name: name,
+                read: true,
+                write: false,
+                type: type,
+                role: role,
+            },
+            native: {},
+        });
+    }
+}

package/admin/admin.d.ts

@@ -1,58 +0,0 @@
-declare let systemDictionary: Record<string, Record<string, string>>;
-
-declare let load: (settings: Record<string, unknown>, onChange: (hasChanges: boolean) => void) => void;
-declare let save: (callback: (settings: Record<string, unknown>) => void) => void;
-
-// make load and save exist on the window object
-interface Window {
-    load: typeof load;
-    save: typeof save;
-}
-
-declare const instance: number;
-declare const adapter: string;
-/** Translates text */
-declare function _(text: string): string;
-declare const socket: ioBrokerSocket;
-declare function sendTo(
-    instance: any | null,
-    command: string,
-    message: any,
-    callback: (result: SendToResult) => void | Promise<void>,
-): void;
-
-interface SendToResult {
-    error?: string | Error;
-    result?: any;
-}
-
-// tslint:disable-next-line:class-name
-interface ioBrokerSocket {
-    emit(command: 'subscribeObjects', pattern: string, callback?: (err?: string) => void | Promise<void>): void;
-    emit(command: 'subscribeStates', pattern: string, callback?: (err?: string) => void | Promise<void>): void;
-    emit(command: 'unsubscribeObjects', pattern: string, callback?: (err?: string) => void | Promise<void>): void;
-    emit(command: 'unsubscribeStates', pattern: string, callback?: (err?: string) => void | Promise<void>): void;
-
-    emit(
-        event: 'getObjectView',
-        view: 'system',
-        type: 'device',
-        options: ioBroker.GetObjectViewParams,
-        callback: (err: string | undefined, result?: any) => void | Promise<void>,
-    ): void;
-    emit(event: 'getStates', callback: (err: string | undefined, result?: Record<string, any>) => void): void;
-    emit(event: 'getState', id: string, callback: (err: string | undefined, result?: ioBroker.State) => void): void;
-    emit(
-        event: 'setState',
-        id: string,
-        state: unknown,
-        callback: (err: string | undefined, result?: any) => void,
-    ): void;
-
-    on(event: 'objectChange', handler: ioBroker.ObjectChangeHandler): void;
-    on(event: 'stateChange', handler: ioBroker.StateChangeHandler): void;
-    removeEventHandler(event: 'objectChange', handler: ioBroker.ObjectChangeHandler): void;
-    removeEventHandler(event: 'stateChange', handler: ioBroker.StateChangeHandler): void;
-
-    // TODO: other events
-}

package/admin/index_m.html

@@ -1,126 +0,0 @@
-<html>
-    <head>
-        <!-- Load ioBroker scripts and styles-->
-        <link rel="stylesheet" type="text/css" href="../../css/adapter.css" />
-        <link rel="stylesheet" type="text/css" href="../../lib/css/materialize.css" />
-
-        <script type="text/javascript" src="../../lib/js/jquery-3.2.1.min.js"></script>
-        <script type="text/javascript" src="../../socket.io/socket.io.js"></script>
-
-        <script type="text/javascript" src="../../js/translate.js"></script>
-        <script type="text/javascript" src="../../lib/js/materialize.js"></script>
-        <script type="text/javascript" src="../../js/adapter-settings.js"></script>
-
-        <!-- Load our own files -->
-        <link rel="stylesheet" type="text/css" href="style.css" />
-        <script type="text/javascript" src="words.js"></script>
-
-        <script type="text/javascript">
-            // This will be called by the admin adapter when the settings page loads
-            function load(settings, onChange) {
-                // example: select elements with id=key and class=value and insert value
-                if (!settings) return;
-
-                // set defaults for newly added parameters
-                settings.weatherServer = settings.weatherServer || 'all';
-
-                $('.value').each(function () {
-                    var $key = $(this);
-                    var id = $key.attr('id');
-                    if ($key.attr('type') === 'checkbox') {
-                        // do not call onChange direct, because onChange could expect some arguments
-                        $key.prop('checked', settings[id]).on('change', () => onChange());
-                    } else {
-                        // do not call onChange direct, because onChange could expect some arguments
-                        $key.val(settings[id])
-                            .on('change', () => onChange())
-                            .on('keyup', () => onChange());
-                    }
-                });
-                onChange(false);
-                // reinitialize all the Materialize labels on the page if you are dynamically adding inputs:
-                if (M) M.updateTextFields();
-            }
-
-            // This will be called by the admin adapter when the user presses the save button
-            function save(callback) {
-                // example: select elements with class=value and build settings object
-                var obj = {};
-                $('.value').each(function () {
-                    var $this = $(this);
-                    if ($this.attr('type') === 'checkbox') {
-                        obj[$this.attr('id')] = $this.prop('checked');
-                    } else {
-                        obj[$this.attr('id')] = $this.val();
-                    }
-                });
-                callback(obj);
-            }
-        </script>
-    </head>
-
-    <body>
-        <div class="m adapter-container">
-            <div class="row">
-                <div class="col s12 m4 l2">
-                    <img src="loxone.png" class="logo" />
-                </div>
-            </div>
-
-            <div class="row">
-                <div class="col s6 input-field">
-                    <input type="text" class="value" id="host" />
-                    <label for="host" class="translate">Miniserver Hostname / IP</label>
-                </div>
-
-                <div class="col s6 input-field">
-                    <input type="text" class="value" id="port" />
-                    <label for="port" class="translate">Miniserver Port</label>
-                </div>
-            </div>
-
-            <div class="row">
-                <div class="col s6 input-field">
-                    <input type="text" class="value" id="username" />
-                    <label for="username" class="translate">Miniserver Username</label>
-                </div>
-
-                <div class="col s6 input-field">
-                    <input type="password" autocomplete="off" class="value" id="password" />
-                    <label for="password" class="translate">Miniserver Password</label>
-                </div>
-            </div>
-
-            <div class="row">
-                <div class="col s3 translate">Synchronize</div>
-
-                <div class="col s3 input-field">
-                    <input type="checkbox" class="value" id="syncNames" />
-                    <label for="syncNames" class="translate">Names</label>
-                </div>
-
-                <div class="col s3 input-field">
-                    <input type="checkbox" class="value" id="syncRooms" />
-                    <label for="syncRooms" class="translate">Rooms</label>
-                </div>
-
-                <div class="col s3 input-field">
-                    <input type="checkbox" class="value" id="syncFunctions" />
-                    <label for="syncFunctions" class="translate">Functions</label>
-                </div>
-            </div>
-
-            <div class="row">
-                <div class="col s6 input-field">
-                    <select id="weatherServer" class="value">
-                        <option value="off" class="translate">Don't synchronize weather data</option>
-                        <option value="current" class="translate">Synchronize current weather only</option>
-                        <option value="1day" class="translate">Synchronize 24 hours of weather forcast</option>
-                        <option value="all" class="translate">Synchronize entire weather forcast</option>
-                    </select>
-                    <label for="weatherServer" class="translate">Weather Server</label>
-                </div>
-            </div>
-        </div>
-    </body>
-</html>

package/admin/style.css

@@ -1,32 +0,0 @@
-/* You can delete those if you want. I just found them very helpful */
-* {
-    box-sizing: border-box
-}
-.m {
-    /* Don't cut off dropdowns! */
-    overflow: initial;
-}
-.m.adapter-container,
-.m.adapter-container > div.App {
-    /* Fix layout/scrolling issues with tabs */
-    height: 100%;
-    width: 100%;
-    position: relative;
-}
-.m .select-wrapper + label {
-    /* The positioning for dropdown labels is messed up */
-    transform: none !important;
-}
-
-label > i[title] {
-    /* Display the help cursor for the tooltip icons and fix their positioning */
-    cursor: help;
-    margin-left: 0.25em;
-}
-
-.dropdown-content {
-    /* Don't wrap text in dropdowns */
-    white-space: nowrap;
-}
-
-/* Add your styles here */

package/admin/words.js

@@ -1,25 +0,0 @@
-/*global systemDictionary:true */
-/*
-+===================== DO NOT MODIFY ======================+
-| This file was generated by translate-adapter, please use |
-| `translate-adapter adminLanguages2words` to update it.   |
-+===================== DO NOT MODIFY ======================+
-*/
-'use strict';
-
-systemDictionary = {
-    "Don't synchronize weather data": {               "en": "Don't synchronize weather data",                   "de": "Wetterdaten nicht synchronisieren",                "ru": "Не синхронизировать данные о погоде",              "pt": "Não sincronize dados meteorológicos",              "nl": "Synchroniseer geen weergegevens",                  "fr": "Ne pas synchroniser les données météorologiques",  "it": "Non sincronizzare i dati meteorologici",           "es": "No sincronice los datos meteorológicos",           "pl": "Nie synchronizuj danych pogodowych",               "zh-cn": "不同步天气数据"},
-    "Functions": {                                    "en": "Functions",                                        "de": "Funktionen",                                       "ru": "Функции",                                          "pt": "Funções",                                          "nl": "Functies",                                         "fr": "Les fonctions",                                    "it": "Funzioni",                                         "es": "Funciones",                                        "pl": "Funkcje",                                          "zh-cn": "职能"},
-    "Loxone Miniserver adapter settings": {           "en": "Loxone Miniserver adapter settings",               "de": "Loxone Miniserver Adapter-Einstellungen",          "ru": "Настройки драйвера Loxone Miniserver",             "pt": "Configurações do adaptador do Miniserver Loxone",  "nl": "Loxone Miniserver adapter instellingen",           "fr": "Paramètres de l'adaptateur Loxone Miniserver",     "it": "Impostazioni dell'adattatore Loxone Miniserver",   "es": "Configuración del adaptador Loxone Miniserver",    "pl": "Ustawienia adaptera Loxone Miniserver",            "zh-cn": "Loxone Miniserver适配器设置"},
-    "Miniserver Hostname / IP": {                     "en": "Miniserver host name / IP",                        "de": "Hostname / IP des Miniservers",                    "ru": "IP / Hostname Минисервера",                        "pt": "Nome do host / IP do miniservidor",                "nl": "Miniserver hostnaam / IP",                         "fr": "Nom d'hôte / IP du miniserver",                    "it": "Nome host / IP Miniserver",                        "es": "IP / nombre de host del Miniserver",               "pl": "Nazwa / adres IP hosta Miniserver",                "zh-cn": "小型服务器主机名/ IP"},
-    "Miniserver Password": {                          "en": "Miniserver password",                              "de": "Kennwort des Miniservers",                         "ru": "Пароль",                                           "pt": "Senha do Miniserver",                              "nl": "Miniserver wachtwoord",                            "fr": "Mot de passe Miniserver",                          "it": "Password Miniserver",                              "es": "Contraseña de Miniserver",                         "pl": "Hasło miniservera",                                "zh-cn": "小型服务器密码"},
-    "Miniserver Port": {                              "en": "Miniserver port",                                  "de": "Port des Miniservers",                             "ru": "Порт Минисервера",                                 "pt": "Porta do Miniserver",                              "nl": "Miniserver poort",                                 "fr": "Port Miniserver",                                  "it": "Porta Miniserver",                                 "es": "Puerto miniserver",                                "pl": "Port Miniserver",                                  "zh-cn": "小型服务器端口"},
-    "Miniserver Username": {                          "en": "Miniserver username",                              "de": "Benutzername des Miniservers",                     "ru": "Имя пользователя",                                 "pt": "Nome de usuário do Miniserver",                    "nl": "Miniserver gebruikersnaam",                        "fr": "Nom d'utilisateur Miniserver",                     "it": "Nome utente Miniserver",                           "es": "Nombre de usuario de Miniserver",                  "pl": "Nazwa użytkownika Miniserver",                     "zh-cn": "小型服务器用户名"},
-    "Names": {                                        "en": "Names",                                            "de": "Namen",                                            "ru": "Имена",                                            "pt": "Nomes",                                            "nl": "Namen",                                            "fr": "Noms",                                             "it": "Nomi",                                             "es": "Nombres",                                          "pl": "Nazwy",                                            "zh-cn": "名字"},
-    "Rooms": {                                        "en": "Rooms",                                            "de": "Räume",                                            "ru": "Комнаты",                                          "pt": "quartos",                                          "nl": "Ruimtes",                                          "fr": "Pièces",                                           "it": "Camere",                                           "es": "Habitaciones",                                     "pl": "Pokoje",                                           "zh-cn": "房间数"},
-    "Synchronize": {                                  "en": "Synchronize",                                      "de": "Synchronisieren",                                  "ru": "Синхронизация",                                    "pt": "Sincronizar",                                      "nl": "Syncroniseer",                                     "fr": "Synchroniser",                                     "it": "Sincronizzare",                                    "es": "Sincronizar",                                      "pl": "Synchronizować",                                   "zh-cn": "同步化"},
-    "Synchronize 24 hours of weather forcast": {      "en": "Synchronize 24 hours of weather forcast",          "de": "24 Stunden Wettervorhersage synchronisieren",      "ru": "Синхронизация 24-часового прогноза погоды",        "pt": "Sincronizar 24 horas de previsão do tempo",        "nl": "Synchroniseer 24 uur weersvoorspelling",           "fr": "Synchroniser 24 heures de prévisions météo",       "it": "Sincronizza 24 ore di previsione meteo",           "es": "Sincronizar 24 horas de previsión meteorológica",  "pl": "Synchronizuj 24-godzinne prognozy pogody",         "zh-cn": "同步24小时天气预报"},
-    "Synchronize current weather only": {             "en": "Synchronize current weather only",                 "de": "Nur aktuelles Wetter synchronisieren",             "ru": "Синхронизировать только текущую погоду",           "pt": "Sincronizar apenas o clima atual",                 "nl": "Synchroniseer alleen het huidige weer",            "fr": "Synchroniser uniquement la météo actuelle",        "it": "Sincronizza solo il tempo corrente",               "es": "Sincronizar solo el clima actual",                 "pl": "Synchronizuj tylko aktualną pogodę",               "zh-cn": "仅同步当前天气"},
-    "Synchronize entire weather forcast": {           "en": "Synchronize entire weather forcast",               "de": "Gesamte Wettervorhersage synchronisieren",         "ru": "Синхронизировать весь прогноз погоды",             "pt": "Sincronizar previsão do tempo inteiro",            "nl": "Synchroniseer de volledige weersvoorspelling",     "fr": "Synchroniser toutes les prévisions météorologiques", "it": "Sincronizza l'intera previsione meteo",            "es": "Sincronizar todo el pronóstico del tiempo",        "pl": "Synchronizuj całą prognozę pogody",                "zh-cn": "同步整个天气预报"},
-    "Weather Server": {                               "en": "Weather Server",                                   "de": "Wetterserver",                                     "ru": "Сервер погоды",                                    "pt": "Servidor Meteorológico",                           "nl": "Weer Server",                                      "fr": "Serveur météo",                                    "it": "Weather Server",                                   "es": "Servidor meteorológico",                           "pl": "Serwer pogody",                                    "zh-cn": "天气服务器"},
-};