Merge branch 'master' into separate-config

MqttTopics.h

@@ -55,6 +55,8 @@
 #define mqtt_topic_keypad_command_enabled "/keypad/command/enabled"
 #define mqtt_topic_keypad_command_result "/keypad/command/commandResult"
 #define mqtt_topic_keypad_json "/keypad/json"
+#define mqtt_topic_keypad_json_action "/keypad/actionJson"
+#define mqtt_topic_keypad_json_command_result "/keypad/commandResultJson"
 
 #define mqtt_topic_info_hardware_version "/info/hardwareVersion"
 #define mqtt_topic_info_firmware_version "/info/firmwareVersion"

NetworkLock.cpp

@@ -65,12 +65,14 @@ void NetworkLock::initialize()
         _network->subscribe(_mqttPath, mqtt_topic_keypad_command_code);
         _network->subscribe(_mqttPath, mqtt_topic_keypad_command_enabled);
         _network->subscribe(_mqttPath, mqtt_topic_query_keypad);
+        _network->subscribe(_mqttPath, mqtt_topic_keypad_json_action);
         _network->initTopic(_mqttPath, mqtt_topic_keypad_command_action, "--");
         _network->initTopic(_mqttPath, mqtt_topic_keypad_command_id, "0");
         _network->initTopic(_mqttPath, mqtt_topic_keypad_command_name, "--");
         _network->initTopic(_mqttPath, mqtt_topic_keypad_command_code, "000000");
         _network->initTopic(_mqttPath, mqtt_topic_keypad_command_enabled, "1");
         _network->initTopic(_mqttPath, mqtt_topic_query_keypad, "0");
+        _network->initTopic(_mqttPath, mqtt_topic_keypad_json_action, "--");
     }
 
     _network->addReconnectedCallback([&]()
@@ -197,6 +199,18 @@ void NetworkLock::onMqttDataReceived(const char* topic, byte* payload, const uns
         
         publishString(mqtt_topic_config_action, "--");
     }
+
+    if(comparePrefixedPath(topic, mqtt_topic_keypad_json_action))
+    {
+        if(strcmp(value, "") == 0 || strcmp(value, "--") == 0) return;
+
+        if(_keypadJsonCommandReceivedReceivedCallback != NULL)
+        {
+            _keypadJsonCommandReceivedReceivedCallback(value);
+        }
+
+        publishString(mqtt_topic_keypad_json_action, "--");
+    }
 }
 
 void NetworkLock::publishKeyTurnerState(const NukiLock::KeyTurnerState& keyTurnerState, const NukiLock::KeyTurnerState& lastKeyTurnerState)
@@ -587,16 +601,78 @@ void NetworkLock::publishKeypad(const std::list<NukiLock::KeypadEntry>& entries,
 
         auto jsonEntry = json.add();
 
-        jsonEntry["id"] = entry.codeId;
+        jsonEntry["codeId"] = entry.codeId;
         jsonEntry["enabled"] = entry.enabled;
         jsonEntry["name"] = entry.name;
-        jsonEntry["createdYear"] = entry.dateCreatedYear;
-        jsonEntry["createdMonth"] = entry.dateCreatedMonth;
-        jsonEntry["createdDay"] = entry.dateCreatedDay;
-        jsonEntry["createdHour"] = entry.dateCreatedHour;
-        jsonEntry["createdMin"] = entry.dateCreatedMin;
-        jsonEntry["createdSec"] = entry.dateCreatedSec;
+        char createdDT[20];
+        sprintf(createdDT, "%04d-%02d-%02d %02d:%02d:%02d", entry.dateCreatedYear, entry.dateCreatedMonth, entry.dateCreatedDay, entry.dateCreatedHour, entry.dateCreatedMin, entry.dateCreatedSec);
+        jsonEntry["dateCreated"] = createdDT;
         jsonEntry["lockCount"] = entry.lockCount;
+        char lastActiveDT[20];
+        sprintf(lastActiveDT, "%04d-%02d-%02d %02d:%02d:%02d", entry.dateLastActiveYear, entry.dateLastActiveMonth, entry.dateLastActiveDay, entry.dateLastActiveHour, entry.dateLastActiveMin, entry.dateLastActiveSec);
+        jsonEntry["dateLastActive"] = lastActiveDT;
+        jsonEntry["timeLimited"] = entry.timeLimited;
+        char allowedFromDT[20];
+        sprintf(allowedFromDT, "%04d-%02d-%02d %02d:%02d:%02d", entry.allowedFromYear, entry.allowedFromMonth, entry.allowedFromDay, entry.allowedFromHour, entry.allowedFromMin, entry.allowedFromSec);
+        jsonEntry["allowedFrom"] = allowedFromDT;
+        char allowedUntilDT[20];
+        sprintf(allowedUntilDT, "%04d-%02d-%02d %02d:%02d:%02d", entry.allowedUntilYear, entry.allowedUntilMonth, entry.allowedUntilDay, entry.allowedUntilHour, entry.allowedUntilMin, entry.allowedUntilSec);
+        jsonEntry["allowedUntil"] = allowedUntilDT;
+
+        uint8_t allowedWeekdaysInt = entry.allowedWeekdays;
+        JsonArray weekdays = jsonEntry.createNestedArray("allowedWeekdays");
+
+        while(allowedWeekdaysInt > 0) {
+            if(allowedWeekdaysInt >= 64)
+            {
+                weekdays.add("mon");
+                allowedWeekdaysInt -= 64;
+                continue;
+            }
+            if(allowedWeekdaysInt >= 32)
+            {
+                weekdays.add("tue");
+                allowedWeekdaysInt -= 32;
+                continue;
+            }
+            if(allowedWeekdaysInt >= 16)
+            {
+                weekdays.add("wed");
+                allowedWeekdaysInt -= 16;
+                continue;
+            }
+            if(allowedWeekdaysInt >= 8)
+            {
+                weekdays.add("thu");
+                allowedWeekdaysInt -= 8;
+                continue;
+            }
+            if(allowedWeekdaysInt >= 4)
+            {
+                weekdays.add("fri");
+                allowedWeekdaysInt -= 4;
+                continue;
+            }
+            if(allowedWeekdaysInt >= 2)
+            {
+                weekdays.add("sat");
+                allowedWeekdaysInt -= 2;
+                continue;
+            }
+            if(allowedWeekdaysInt >= 1)
+            {
+                weekdays.add("sun");
+                allowedWeekdaysInt -= 1;
+                continue;
+            }
+        }
+
+        char allowedFromTimeT[5];
+        sprintf(allowedFromTimeT, "%02d:%02d", entry.allowedFromTimeHour, entry.allowedFromTimeMin);
+        jsonEntry["allowedFromTime"] = allowedFromTimeT;
+        char allowedUntilTimeT[5];
+        sprintf(allowedUntilTimeT, "%02d:%02d", entry.allowedUntilTimeHour, entry.allowedUntilTimeMin);
+        jsonEntry["allowedUntilTime"] = allowedUntilTimeT;
 
         ++index;
     }
@@ -627,6 +703,11 @@ void NetworkLock::publishKeypadCommandResult(const char* result)
     publishString(mqtt_topic_keypad_command_result, result);
 }
 
+void NetworkLock::publishKeypadJsonCommandResult(const char* result)
+{
+    publishString(mqtt_topic_keypad_json_command_result, result);
+}
+
 void NetworkLock::setLockActionReceivedCallback(LockActionResult (*lockActionReceivedCallback)(const char *))
 {
     _lockActionReceivedCallback = lockActionReceivedCallback;
@@ -642,6 +723,11 @@ void NetworkLock::setKeypadCommandReceivedCallback(void (*keypadCommandReceivedR
     _keypadCommandReceivedReceivedCallback = keypadCommandReceivedReceivedCallback;
 }
 
+void NetworkLock::setKeypadJsonCommandReceivedCallback(void (*keypadJsonCommandReceivedReceivedCallback)(const char *))
+{
+    _keypadJsonCommandReceivedReceivedCallback = keypadJsonCommandReceivedReceivedCallback;
+}
+
 void NetworkLock::buildMqttPath(const char* path, char* outPath)
 {
     int offset = 0;

NetworkLock.h

@@ -39,11 +39,13 @@ public:
     void publishKeypad(const std::list<NukiLock::KeypadEntry>& entries, uint maxKeypadCodeCount);
     void publishConfigCommandResult(const char* result);
     void publishKeypadCommandResult(const char* result);
+    void publishKeypadJsonCommandResult(const char* result);
 
     void setLockActionReceivedCallback(LockActionResult (*lockActionReceivedCallback)(const char* value));
     void setConfigUpdateReceivedCallback(void (*configUpdateReceivedCallback)(const char* value));
     void setKeypadCommandReceivedCallback(void (*keypadCommandReceivedReceivedCallback)(const char* command, const uint& id, const String& name, const String& code, const int& enabled));
-
+    void setKeypadJsonCommandReceivedCallback(void (*keypadJsonCommandReceivedReceivedCallback)(const char* value));
+    
     void onMqttDataReceived(const char* topic, byte* payload, const unsigned int length) override;
 
     bool reconnected();
@@ -96,4 +98,5 @@ private:
     LockActionResult (*_lockActionReceivedCallback)(const char* value) = nullptr;
     void (*_configUpdateReceivedCallback)(const char* value) = nullptr;
     void (*_keypadCommandReceivedReceivedCallback)(const char* command, const uint& id, const String& name, const String& code, const int& enabled) = nullptr;
+    void (*_keypadJsonCommandReceivedReceivedCallback)(const char* value) = nullptr;
 };

NetworkOpener.cpp

@@ -56,12 +56,14 @@ void NetworkOpener::initialize()
         _network->subscribe(_mqttPath, mqtt_topic_keypad_command_code);
         _network->subscribe(_mqttPath, mqtt_topic_keypad_command_enabled);
         _network->subscribe(_mqttPath, mqtt_topic_query_keypad);
+        _network->subscribe(_mqttPath, mqtt_topic_keypad_json_action);
         _network->initTopic(_mqttPath, mqtt_topic_keypad_command_action, "--");
         _network->initTopic(_mqttPath, mqtt_topic_keypad_command_id, "0");
         _network->initTopic(_mqttPath, mqtt_topic_keypad_command_name, "--");
         _network->initTopic(_mqttPath, mqtt_topic_keypad_command_code, "000000");
         _network->initTopic(_mqttPath, mqtt_topic_keypad_command_enabled, "1");
         _network->initTopic(_mqttPath, mqtt_topic_query_keypad, "0");
+        _network->initTopic(_mqttPath, mqtt_topic_keypad_json_action, "--");
     }
 
     _network->addReconnectedCallback([&]()
@@ -189,6 +191,18 @@ void NetworkOpener::onMqttDataReceived(const char* topic, byte* payload, const u
 
         publishString(mqtt_topic_config_action, "--");
     }
+
+    if(comparePrefixedPath(topic, mqtt_topic_keypad_json_action))
+    {
+        if(strcmp(value, "") == 0 || strcmp(value, "--") == 0) return;
+
+        if(_keypadJsonCommandReceivedReceivedCallback != NULL)
+        {
+            _keypadJsonCommandReceivedReceivedCallback(value);
+        }
+
+        publishString(mqtt_topic_keypad_json_action, "--");
+    }
 }
 
 void NetworkOpener::publishKeyTurnerState(const NukiOpener::OpenerState& keyTurnerState, const NukiOpener::OpenerState& lastKeyTurnerState)
@@ -646,16 +660,78 @@ void NetworkOpener::publishKeypad(const std::list<NukiLock::KeypadEntry>& entrie
 
         auto jsonEntry = json.add();
 
-        jsonEntry["id"] = entry.codeId;
+        jsonEntry["codeId"] = entry.codeId;
         jsonEntry["enabled"] = entry.enabled;
         jsonEntry["name"] = entry.name;
-        jsonEntry["createdYear"] = entry.dateCreatedYear;
-        jsonEntry["createdMonth"] = entry.dateCreatedMonth;
-        jsonEntry["createdDay"] = entry.dateCreatedDay;
-        jsonEntry["createdHour"] = entry.dateCreatedHour;
-        jsonEntry["createdMin"] = entry.dateCreatedMin;
-        jsonEntry["createdSec"] = entry.dateCreatedSec;
+        char createdDT[20];
+        sprintf(createdDT, "%04d-%02d-%02d %02d:%02d:%02d", entry.dateCreatedYear, entry.dateCreatedMonth, entry.dateCreatedDay, entry.dateCreatedHour, entry.dateCreatedMin, entry.dateCreatedSec);
+        jsonEntry["dateCreated"] = createdDT;
         jsonEntry["lockCount"] = entry.lockCount;
+        char lastActiveDT[20];
+        sprintf(lastActiveDT, "%04d-%02d-%02d %02d:%02d:%02d", entry.dateLastActiveYear, entry.dateLastActiveMonth, entry.dateLastActiveDay, entry.dateLastActiveHour, entry.dateLastActiveMin, entry.dateLastActiveSec);
+        jsonEntry["dateLastActive"] = lastActiveDT;
+        jsonEntry["timeLimited"] = entry.timeLimited;
+        char allowedFromDT[20];
+        sprintf(allowedFromDT, "%04d-%02d-%02d %02d:%02d:%02d", entry.allowedFromYear, entry.allowedFromMonth, entry.allowedFromDay, entry.allowedFromHour, entry.allowedFromMin, entry.allowedFromSec);
+        jsonEntry["allowedFrom"] = allowedFromDT;
+        char allowedUntilDT[20];
+        sprintf(allowedUntilDT, "%04d-%02d-%02d %02d:%02d:%02d", entry.allowedUntilYear, entry.allowedUntilMonth, entry.allowedUntilDay, entry.allowedUntilHour, entry.allowedUntilMin, entry.allowedUntilSec);
+        jsonEntry["allowedUntil"] = allowedUntilDT;
+
+        uint8_t allowedWeekdaysInt = entry.allowedWeekdays;
+        JsonArray weekdays = jsonEntry.createNestedArray("allowedWeekdays");
+
+        while(allowedWeekdaysInt > 0) {
+            if(allowedWeekdaysInt >= 64)
+            {
+                weekdays.add("mon");
+                allowedWeekdaysInt -= 64;
+                continue;
+            }
+            if(allowedWeekdaysInt >= 32)
+            {
+                weekdays.add("tue");
+                allowedWeekdaysInt -= 32;
+                continue;
+            }
+            if(allowedWeekdaysInt >= 16)
+            {
+                weekdays.add("wed");
+                allowedWeekdaysInt -= 16;
+                continue;
+            }
+            if(allowedWeekdaysInt >= 8)
+            {
+                weekdays.add("thu");
+                allowedWeekdaysInt -= 8;
+                continue;
+            }
+            if(allowedWeekdaysInt >= 4)
+            {
+                weekdays.add("fri");
+                allowedWeekdaysInt -= 4;
+                continue;
+            }
+            if(allowedWeekdaysInt >= 2)
+            {
+                weekdays.add("sat");
+                allowedWeekdaysInt -= 2;
+                continue;
+            }
+            if(allowedWeekdaysInt >= 1)
+            {
+                weekdays.add("sun");
+                allowedWeekdaysInt -= 1;
+                continue;
+            }
+        }
+
+        char allowedFromTimeT[5];
+        sprintf(allowedFromTimeT, "%02d:%02d", entry.allowedFromTimeHour, entry.allowedFromTimeMin);
+        jsonEntry["allowedFromTime"] = allowedFromTimeT;
+        char allowedUntilTimeT[5];
+        sprintf(allowedUntilTimeT, "%02d:%02d", entry.allowedUntilTimeHour, entry.allowedUntilTimeMin);
+        jsonEntry["allowedUntilTime"] = allowedUntilTimeT;
 
         ++index;
     }
@@ -686,6 +762,11 @@ void NetworkOpener::publishKeypadCommandResult(const char* result)
     publishString(mqtt_topic_keypad_command_result, result);
 }
 
+void NetworkOpener::publishKeypadJsonCommandResult(const char* result)
+{
+    publishString(mqtt_topic_keypad_json_command_result, result);
+}
+
 void NetworkOpener::setLockActionReceivedCallback(LockActionResult (*lockActionReceivedCallback)(const char *))
 {
     _lockActionReceivedCallback = lockActionReceivedCallback;
@@ -701,6 +782,11 @@ void NetworkOpener::setKeypadCommandReceivedCallback(void (*keypadCommandReceive
     _keypadCommandReceivedReceivedCallback = keypadCommandReceivedReceivedCallback;
 }
 
+void NetworkOpener::setKeypadJsonCommandReceivedCallback(void (*keypadJsonCommandReceivedReceivedCallback)(const char *))
+{
+    _keypadJsonCommandReceivedReceivedCallback = keypadJsonCommandReceivedReceivedCallback;
+}
+
 void NetworkOpener::publishFloat(const char *topic, const float value, const uint8_t precision)
 {
     _network->publishFloat(_mqttPath, topic, value, precision);

NetworkOpener.h

@@ -36,11 +36,13 @@ public:
     void publishKeypad(const std::list<NukiLock::KeypadEntry>& entries, uint maxKeypadCodeCount);
     void publishConfigCommandResult(const char* result);
     void publishKeypadCommandResult(const char* result);
+    void publishKeypadJsonCommandResult(const char* result);
 
     void setLockActionReceivedCallback(LockActionResult (*lockActionReceivedCallback)(const char* value));
     void setConfigUpdateReceivedCallback(void (*configUpdateReceivedCallback)(const char* value));
     void setKeypadCommandReceivedCallback(void (*keypadCommandReceivedReceivedCallback)(const char* command, const uint& id, const String& name, const String& code, const int& enabled));
-
+    void setKeypadJsonCommandReceivedCallback(void (*keypadJsonCommandReceivedReceivedCallback)(const char* value));
+    
     void onMqttDataReceived(const char* topic, byte* payload, const unsigned int length) override;
 
     bool reconnected();
@@ -101,4 +103,5 @@ private:
     LockActionResult (*_lockActionReceivedCallback)(const char* value) = nullptr;
     void (*_configUpdateReceivedCallback)(const char* value) = nullptr;
     void (*_keypadCommandReceivedReceivedCallback)(const char* command, const uint& id, const String& name, const String& code, const int& enabled) = nullptr;
+    void (*_keypadJsonCommandReceivedReceivedCallback)(const char* value) = nullptr;
 };

NukiOpenerWrapper.cpp

@@ -32,6 +32,7 @@ NukiOpenerWrapper::NukiOpenerWrapper(const std::string& deviceName, NukiDeviceId
     network->setLockActionReceivedCallback(nukiOpenerInst->onLockActionReceivedCallback);
     network->setConfigUpdateReceivedCallback(nukiOpenerInst->onConfigUpdateReceivedCallback);
     network->setKeypadCommandReceivedCallback(nukiOpenerInst->onKeypadCommandReceivedCallback);
+    network->setKeypadJsonCommandReceivedCallback(nukiOpenerInst->onKeypadJsonCommandReceivedCallback);
 
     _gpio->addCallback(NukiOpenerWrapper::gpioActionCallback);
 }
@@ -87,13 +88,6 @@ void NukiOpenerWrapper::initialize()
         _intervalKeypad = 60 * 30;
         _preferences->putInt(preference_query_interval_keypad, _intervalKeypad);
     }
-    /*
-    if(_intervalKeypad == 0)
-    {
-        _intervalKeypad = 60 * 30;
-        _preferences->putInt(preference_query_interval_keypad, _intervalKeypad);
-    }
-     */
     if(_restartBeaconTimeout < 10)
     {
         _restartBeaconTimeout = -1;
@@ -407,7 +401,7 @@ void NukiOpenerWrapper::updateConfig()
 
         if(_preferences->getUInt(preference_nuki_id_opener, 0) == _nukiConfig.nukiId)
         {
-            _hasKeypad = _nukiConfig.hasKeypad > 0 || _nukiConfig.hasKeypadV2;
+            _hasKeypad = _nukiConfig.hasKeypad > 0 || _nukiConfig.hasKeypadV2 > 0;
             _firmwareVersion = std::to_string(_nukiConfig.firmwareVersion[0]) + "." + std::to_string(_nukiConfig.firmwareVersion[1]) + "." + std::to_string(_nukiConfig.firmwareVersion[2]);
             _hardwareVersion = std::to_string(_nukiConfig.hardwareRevision[0]) + "." + std::to_string(_nukiConfig.hardwareRevision[1]);
             _network->publishConfig(_nukiConfig);
@@ -1179,6 +1173,11 @@ void NukiOpenerWrapper::onKeypadCommandReceivedCallback(const char *command, con
     nukiOpenerInst->onKeypadCommandReceived(command, id, name, code, enabled);
 }
 
+void NukiOpenerWrapper::onKeypadJsonCommandReceivedCallback(const char *value)
+{
+    nukiOpenerInst->onKeypadJsonCommandReceived(value);
+}
+
 void NukiOpenerWrapper::gpioActionCallback(const GpioAction &action, const int& pin)
 {
     switch(action)
@@ -1321,6 +1320,350 @@ void NukiOpenerWrapper::onKeypadCommandReceived(const char *command, const uint
     }
 }
 
+void NukiOpenerWrapper::onKeypadJsonCommandReceived(const char *value)
+{
+    if(_nukiOpener.getSecurityPincode() == 0)
+    {
+        _network->publishKeypadJsonCommandResult("noPinSet");
+        return;
+    }
+
+    if(!_preferences->getBool(preference_keypad_control_enabled))
+    {
+        _network->publishKeypadJsonCommandResult("keypadControlDisabled");
+        return;
+    }
+
+    if(!_hasKeypad)
+    {
+        if(_configRead && _nukiConfigValid)
+        {
+            _network->publishKeypadJsonCommandResult("keypadNotAvailable");
+            return;
+        }
+
+        updateConfig();
+
+        while (!_nukiConfigValid && _retryConfigCount < 11)
+        {
+            updateConfig();
+        }
+
+        if(_configRead && _nukiConfigValid)
+        {
+            _network->publishKeypadJsonCommandResult("keypadNotAvailable");
+            return;
+        }
+
+        _network->publishKeypadJsonCommandResult("invalidConfig");
+        return;
+    }
+
+    if(!_keypadEnabled)
+    {
+        _network->publishKeypadJsonCommandResult("keypadDisabled");
+        return;
+    }
+
+    DynamicJsonDocument json(2048);
+    DeserializationError jsonError = deserializeJson(json, value);
+
+    if(jsonError)
+    {
+        _network->publishKeypadJsonCommandResult("invalidJson");
+        return;
+    }
+
+    Nuki::CmdResult result = (Nuki::CmdResult)-1;
+
+    const char *action = json["action"].as<const char*>();
+    uint16_t codeId = json["codeId"].as<unsigned int>();
+    uint32_t code = json["code"].as<unsigned int>();
+    String codeStr = json["code"].as<String>();
+    const char *name = json["name"].as<const char*>();
+    uint8_t enabled = json["enabled"].as<unsigned int>();
+    uint8_t timeLimited = json["timeLimited"].as<unsigned int>();
+    const char *allowedFrom = json["allowedFrom"].as<const char*>();
+    const char *allowedUntil = json["allowedUntil"].as<const char*>();
+    String allowedWeekdays = json["allowedWeekdays"].as<String>();
+    const char *allowedFromTime = json["allowedFromTime"].as<const char*>();
+    const char *allowedUntilTime = json["allowedUntilTime"].as<const char*>();
+
+    if(action)
+    {
+        bool idExists = false;
+
+        if(codeId)
+        {
+            idExists = std::find(_keypadCodeIds.begin(), _keypadCodeIds.end(), codeId) != _keypadCodeIds.end();
+        }
+
+        if(strcmp(action, "delete") == 0) {
+            if(idExists)
+            {
+                result = _nukiOpener.deleteKeypadEntry(codeId);
+                Log->print("Delete keypad code: ");
+                Log->println((int)result);
+            }
+            else
+            {
+                _network->publishKeypadJsonCommandResult("noExistingCodeIdSet");
+                return;
+            }
+        }
+        else if(strcmp(action, "add") == 0 || strcmp(action, "update") == 0)
+        {
+            if(!name)
+            {
+                _network->publishKeypadJsonCommandResult("noNameSet");
+                return;
+            }
+
+            if(code)
+            {
+                bool codeValid = code > 100000 && code < 1000000 && (codeStr.indexOf('0') == -1);
+
+                if (!codeValid)
+                {
+                    _network->publishKeypadJsonCommandResult("noValidCodeSet");
+                    return;
+                }
+            }
+            else
+            {
+                _network->publishKeypadJsonCommandResult("noCodeSet");
+                return;
+            }
+
+            unsigned int allowedFromAr[6];
+            unsigned int allowedUntilAr[6];
+            unsigned int allowedFromTimeAr[2];
+            unsigned int allowedUntilTimeAr[2];
+            uint8_t allowedWeekdaysInt = 0;
+
+            if(timeLimited == 1 && enabled != 0)
+            {
+                if(allowedFrom)
+                {
+                    if(strlen(allowedFrom) == 19)
+                    {
+                        String allowedFromStr = allowedFrom;
+                        allowedFromAr[0] = (uint16_t)allowedFromStr.substring(0, 4).toInt();
+                        allowedFromAr[1] = (uint8_t)allowedFromStr.substring(5, 7).toInt();
+                        allowedFromAr[2] = (uint8_t)allowedFromStr.substring(8, 10).toInt();
+                        allowedFromAr[3] = (uint8_t)allowedFromStr.substring(11, 13).toInt();
+                        allowedFromAr[4] = (uint8_t)allowedFromStr.substring(14, 16).toInt();
+                        allowedFromAr[5] = (uint8_t)allowedFromStr.substring(17, 19).toInt();
+
+                        if(allowedFromAr[0] < 2000 || allowedFromAr[0] > 3000 || allowedFromAr[1] < 1 || allowedFromAr[1] > 12 || allowedFromAr[2] < 1 || allowedFromAr[2] > 31 || allowedFromAr[3] < 0 || allowedFromAr[3] > 23 || allowedFromAr[4] < 0 || allowedFromAr[4] > 59 || allowedFromAr[5] < 0 || allowedFromAr[5] > 59)
+                        {
+                            _network->publishKeypadJsonCommandResult("invalidAllowedFrom");
+                            return;
+                        }
+                    }
+                    else
+                    {
+                        _network->publishKeypadJsonCommandResult("invalidAllowedFrom");
+                        return;
+                    }
+                }
+
+                if(allowedUntil)
+                {
+                    if(strlen(allowedUntil) == 19)
+                    {
+                        String allowedUntilStr = allowedUntil;
+                        allowedUntilAr[0] = (uint16_t)allowedUntilStr.substring(0, 4).toInt();
+                        allowedUntilAr[1] = (uint8_t)allowedUntilStr.substring(5, 7).toInt();
+                        allowedUntilAr[2] = (uint8_t)allowedUntilStr.substring(8, 10).toInt();
+                        allowedUntilAr[3] = (uint8_t)allowedUntilStr.substring(11, 13).toInt();
+                        allowedUntilAr[4] = (uint8_t)allowedUntilStr.substring(14, 16).toInt();
+                        allowedUntilAr[5] = (uint8_t)allowedUntilStr.substring(17, 19).toInt();
+
+                        if(allowedUntilAr[0] < 2000 || allowedUntilAr[0] > 3000 || allowedUntilAr[1] < 1 || allowedUntilAr[1] > 12 || allowedUntilAr[2] < 1 || allowedUntilAr[2] > 31 || allowedUntilAr[3] < 0 || allowedUntilAr[3] > 23 || allowedUntilAr[4] < 0 || allowedUntilAr[4] > 59 || allowedUntilAr[5] < 0 || allowedUntilAr[5] > 59)
+                        {
+                            _network->publishKeypadJsonCommandResult("invalidAllowedUntil");
+                            return;
+                        }
+                    }
+                    else
+                    {
+                        _network->publishKeypadJsonCommandResult("invalidAllowedUntil");
+                        return;
+                    }
+                }
+
+                if(allowedFromTime)
+                {
+                    if(strlen(allowedFromTime) == 5)
+                    {
+                        String allowedFromTimeStr = allowedFromTime;
+                        allowedFromTimeAr[0] = (uint8_t)allowedFromTimeStr.substring(0, 2).toInt();
+                        allowedFromTimeAr[1] = (uint8_t)allowedFromTimeStr.substring(3, 5).toInt();
+
+                        if(allowedFromTimeAr[0] < 0 || allowedFromTimeAr[0] > 23 || allowedFromTimeAr[1] < 0 || allowedFromTimeAr[1] > 59)
+                        {
+                            _network->publishKeypadJsonCommandResult("invalidAllowedFromTime");
+                            return;
+                        }
+                    }
+                    else
+                    {
+                        _network->publishKeypadJsonCommandResult("invalidAllowedFromTime");
+                        return;
+                    }
+                }
+
+                if(allowedUntilTime)
+                {
+                    if(strlen(allowedUntilTime) == 5)
+                    {
+                        String allowedUntilTimeStr = allowedUntilTime;
+                        allowedUntilTimeAr[0] = (uint8_t)allowedUntilTimeStr.substring(0, 2).toInt();
+                        allowedUntilTimeAr[1] = (uint8_t)allowedUntilTimeStr.substring(3, 5).toInt();
+
+                        if(allowedUntilTimeAr[0] < 0 || allowedUntilTimeAr[0] > 23 || allowedUntilTimeAr[1] < 0 || allowedUntilTimeAr[1] > 59)
+                        {
+                            _network->publishKeypadJsonCommandResult("invalidAllowedUntilTime");
+                            return;
+                        }
+                    }
+                    else
+                    {
+                        _network->publishKeypadJsonCommandResult("invalidAllowedUntilTime");
+                        return;
+                    }
+                }
+                
+                if(allowedWeekdays.indexOf("mon") >= 0) allowedWeekdaysInt += 64;
+                if(allowedWeekdays.indexOf("tue") >= 0) allowedWeekdaysInt += 32;
+                if(allowedWeekdays.indexOf("wed") >= 0) allowedWeekdaysInt += 16;
+                if(allowedWeekdays.indexOf("thu") >= 0) allowedWeekdaysInt += 8;
+                if(allowedWeekdays.indexOf("fri") >= 0) allowedWeekdaysInt += 4;
+                if(allowedWeekdays.indexOf("sat") >= 0) allowedWeekdaysInt += 2;
+                if(allowedWeekdays.indexOf("sun") >= 0) allowedWeekdaysInt += 1;
+            }
+            
+            if(strcmp(action, "add") == 0)
+            {
+                NukiOpener::NewKeypadEntry entry;
+                memset(&entry, 0, sizeof(entry));
+                size_t nameLen = strlen(name);
+                memcpy(&entry.name, name, nameLen > 20 ? 20 : nameLen);
+                entry.code = code;
+                entry.timeLimited = timeLimited == 1 ? 1 : 0;
+
+                if(allowedFrom)
+                {
+                    entry.allowedFromYear = allowedFromAr[0];
+                    entry.allowedFromMonth = allowedFromAr[1];
+                    entry.allowedFromDay = allowedFromAr[2];
+                    entry.allowedFromHour = allowedFromAr[3];
+                    entry.allowedFromMin = allowedFromAr[4];
+                    entry.allowedFromSec = allowedFromAr[5];
+                }
+
+                if(allowedUntil)
+                {
+                    entry.allowedUntilYear = allowedUntilAr[0];
+                    entry.allowedUntilMonth = allowedUntilAr[1];
+                    entry.allowedUntilDay = allowedUntilAr[2];
+                    entry.allowedUntilHour = allowedUntilAr[3];
+                    entry.allowedUntilMin = allowedUntilAr[4];
+                    entry.allowedUntilSec = allowedUntilAr[5];
+                }
+
+                entry.allowedWeekdays = allowedWeekdaysInt;
+
+                if(allowedFromTime)
+                {
+                    entry.allowedFromTimeHour = allowedFromTimeAr[0];
+                    entry.allowedFromTimeMin = allowedFromTimeAr[1];
+                }
+
+                if(allowedUntilTime)
+                {
+                    entry.allowedUntilTimeHour = allowedUntilTimeAr[0];
+                    entry.allowedUntilTimeMin = allowedUntilTimeAr[1];
+                }
+
+                result = _nukiOpener.addKeypadEntry(entry);
+                Log->print("Add keypad code: ");
+                Log->println((int)result);
+            }
+            else if (strcmp(action, "update") == 0)
+            {
+                NukiOpener::UpdatedKeypadEntry entry;
+                memset(&entry, 0, sizeof(entry));
+                entry.codeId = codeId;
+                size_t nameLen = strlen(name);
+                memcpy(&entry.name, name, nameLen > 20 ? 20 : nameLen);
+                entry.code = code;
+                entry.enabled = enabled == 0 ? 0 : 1;
+                entry.timeLimited = timeLimited == 1 ? 1 : 0;
+
+                if(allowedFrom)
+                {
+                    entry.allowedFromYear = allowedFromAr[0];
+                    entry.allowedFromMonth = allowedFromAr[1];
+                    entry.allowedFromDay = allowedFromAr[2];
+                    entry.allowedFromHour = allowedFromAr[3];
+                    entry.allowedFromMin = allowedFromAr[4];
+                    entry.allowedFromSec = allowedFromAr[5];
+                }
+
+                if(allowedUntil)
+                {
+                    entry.allowedUntilYear = allowedUntilAr[0];
+                    entry.allowedUntilMonth = allowedUntilAr[1];
+                    entry.allowedUntilDay = allowedUntilAr[2];
+                    entry.allowedUntilHour = allowedUntilAr[3];
+                    entry.allowedUntilMin = allowedUntilAr[4];
+                    entry.allowedUntilSec = allowedUntilAr[5];
+                }
+
+                entry.allowedWeekdays = allowedWeekdaysInt;
+
+                if(allowedFromTime)
+                {
+                    entry.allowedFromTimeHour = allowedFromTimeAr[0];
+                    entry.allowedFromTimeMin = allowedFromTimeAr[1];
+                }
+
+                if(allowedUntilTime)
+                {
+                    entry.allowedUntilTimeHour = allowedUntilTimeAr[0];
+                    entry.allowedUntilTimeMin = allowedUntilTimeAr[1];
+                }
+
+                result = _nukiOpener.updateKeypadEntry(entry);
+                Log->print("Update keypad code: ");
+                Log->println((int)result);
+            }
+        }
+        else
+        {
+            _network->publishKeypadJsonCommandResult("invalidAction");
+            return;
+        }
+
+        updateKeypad();
+
+        if((int)result != -1)
+        {
+            char resultStr[15];
+            memset(&resultStr, 0, sizeof(resultStr));
+            NukiOpener::cmdResultToString(result, resultStr);
+            _network->publishKeypadJsonCommandResult(resultStr);
+        }
+    }
+    else
+    {
+        _network->publishKeypadJsonCommandResult("noActionSet");
+        return;
+    }
+}
+
 const NukiOpener::OpenerState &NukiOpenerWrapper::keyTurnerState()
 {
     return _keyTurnerState;

NukiOpenerWrapper.h

@@ -49,9 +49,11 @@ private:
     static LockActionResult onLockActionReceivedCallback(const char* value);
     static void onConfigUpdateReceivedCallback(const char* value);
     static void onKeypadCommandReceivedCallback(const char* command, const uint& id, const String& name, const String& code, const int& enabled);
+    static void onKeypadJsonCommandReceivedCallback(const char* value);
     static void gpioActionCallback(const GpioAction& action, const int& pin);
     void onKeypadCommandReceived(const char* command, const uint& id, const String& name, const String& code, const int& enabled);
     void onConfigUpdateReceived(const char* value);
+    void onKeypadJsonCommandReceived(const char* value);
 
     void updateKeyTurnerState();
     void updateBatteryState();

NukiWrapper.cpp

@@ -32,6 +32,7 @@ NukiWrapper::NukiWrapper(const std::string& deviceName, NukiDeviceId* deviceId,
     network->setLockActionReceivedCallback(nukiInst->onLockActionReceivedCallback);
     network->setConfigUpdateReceivedCallback(nukiInst->onConfigUpdateReceivedCallback);
     network->setKeypadCommandReceivedCallback(nukiInst->onKeypadCommandReceivedCallback);
+    network->setKeypadJsonCommandReceivedCallback(nukiInst->onKeypadJsonCommandReceivedCallback);
 
     _gpio->addCallback(NukiWrapper::gpioActionCallback);
 }
@@ -380,7 +381,7 @@ void NukiWrapper::updateConfig()
 
         if(_preferences->getUInt(preference_nuki_id_lock, 0) == _nukiConfig.nukiId)
         {
-            _hasKeypad = _nukiConfig.hasKeypad > 0 || _nukiConfig.hasKeypadV2;
+            _hasKeypad = _nukiConfig.hasKeypad > 0 || _nukiConfig.hasKeypadV2 > 0;
             _firmwareVersion = std::to_string(_nukiConfig.firmwareVersion[0]) + "." + std::to_string(_nukiConfig.firmwareVersion[1]) + "." + std::to_string(_nukiConfig.firmwareVersion[2]);
             _hardwareVersion = std::to_string(_nukiConfig.hardwareRevision[0]) + "." + std::to_string(_nukiConfig.hardwareRevision[1]);
             _network->publishConfig(_nukiConfig);
@@ -1157,6 +1158,11 @@ void NukiWrapper::onKeypadCommandReceivedCallback(const char *command, const uin
     nukiInst->onKeypadCommandReceived(command, id, name, code, enabled);
 }
 
+void NukiWrapper::onKeypadJsonCommandReceivedCallback(const char *value)
+{
+    nukiInst->onKeypadJsonCommandReceived(value);
+}
+
 void NukiWrapper::gpioActionCallback(const GpioAction &action, const int& pin)
 {
     switch(action)
@@ -1296,6 +1302,350 @@ void NukiWrapper::onKeypadCommandReceived(const char *command, const uint &id, c
     }
 }
 
+void NukiWrapper::onKeypadJsonCommandReceived(const char *value)
+{
+    if(_nukiLock.getSecurityPincode() == 0)
+    {
+        _network->publishKeypadJsonCommandResult("noPinSet");
+        return;
+    }
+
+    if(!_preferences->getBool(preference_keypad_control_enabled))
+    {
+        _network->publishKeypadJsonCommandResult("keypadControlDisabled");
+        return;
+    }
+
+    if(!_hasKeypad)
+    {
+        if(_configRead && _nukiConfigValid)
+        {
+            _network->publishKeypadJsonCommandResult("keypadNotAvailable");
+            return;
+        }
+
+        updateConfig();
+
+        while (!_nukiConfigValid && _retryConfigCount < 11)
+        {
+            updateConfig();
+        }
+
+        if(_configRead && _nukiConfigValid)
+        {
+            _network->publishKeypadJsonCommandResult("keypadNotAvailable");
+            return;
+        }
+
+        _network->publishKeypadJsonCommandResult("invalidConfig");
+        return;
+    }
+
+    if(!_keypadEnabled)
+    {
+        _network->publishKeypadJsonCommandResult("keypadDisabled");
+        return;
+    }
+
+    DynamicJsonDocument json(2048);
+    DeserializationError jsonError = deserializeJson(json, value);
+
+    if(jsonError)
+    {
+        _network->publishKeypadJsonCommandResult("invalidJson");
+        return;
+    }
+
+    Nuki::CmdResult result = (Nuki::CmdResult)-1;
+
+    const char *action = json["action"].as<const char*>();
+    uint16_t codeId = json["codeId"].as<unsigned int>();
+    uint32_t code = json["code"].as<unsigned int>();
+    String codeStr = json["code"].as<String>();
+    const char *name = json["name"].as<const char*>();
+    uint8_t enabled = json["enabled"].as<unsigned int>();
+    uint8_t timeLimited = json["timeLimited"].as<unsigned int>();
+    const char *allowedFrom = json["allowedFrom"].as<const char*>();
+    const char *allowedUntil = json["allowedUntil"].as<const char*>();
+    String allowedWeekdays = json["allowedWeekdays"].as<String>();
+    const char *allowedFromTime = json["allowedFromTime"].as<const char*>();
+    const char *allowedUntilTime = json["allowedUntilTime"].as<const char*>();
+
+    if(action)
+    {
+        bool idExists = false;
+
+        if(codeId)
+        {
+            idExists = std::find(_keypadCodeIds.begin(), _keypadCodeIds.end(), codeId) != _keypadCodeIds.end();
+        }
+
+        if(strcmp(action, "delete") == 0) {
+            if(idExists)
+            {
+                result = _nukiLock.deleteKeypadEntry(codeId);
+                Log->print("Delete keypad code: ");
+                Log->println((int)result);
+            }
+            else
+            {
+                _network->publishKeypadJsonCommandResult("noExistingCodeIdSet");
+                return;
+            }
+        }
+        else if(strcmp(action, "add") == 0 || strcmp(action, "update") == 0)
+        {
+            if(!name)
+            {
+                _network->publishKeypadJsonCommandResult("noNameSet");
+                return;
+            }
+
+            if(code)
+            {
+                bool codeValid = code > 100000 && code < 1000000 && (codeStr.indexOf('0') == -1);
+
+                if (!codeValid)
+                {
+                    _network->publishKeypadJsonCommandResult("noValidCodeSet");
+                    return;
+                }
+            }
+            else
+            {
+                _network->publishKeypadJsonCommandResult("noCodeSet");
+                return;
+            }
+
+            unsigned int allowedFromAr[6];
+            unsigned int allowedUntilAr[6];
+            unsigned int allowedFromTimeAr[2];
+            unsigned int allowedUntilTimeAr[2];
+            uint8_t allowedWeekdaysInt = 0;
+
+            if(timeLimited == 1 && enabled != 0)
+            {
+                if(allowedFrom)
+                {
+                    if(strlen(allowedFrom) == 19)
+                    {
+                        String allowedFromStr = allowedFrom;
+                        allowedFromAr[0] = (uint16_t)allowedFromStr.substring(0, 4).toInt();
+                        allowedFromAr[1] = (uint8_t)allowedFromStr.substring(5, 7).toInt();
+                        allowedFromAr[2] = (uint8_t)allowedFromStr.substring(8, 10).toInt();
+                        allowedFromAr[3] = (uint8_t)allowedFromStr.substring(11, 13).toInt();
+                        allowedFromAr[4] = (uint8_t)allowedFromStr.substring(14, 16).toInt();
+                        allowedFromAr[5] = (uint8_t)allowedFromStr.substring(17, 19).toInt();
+
+                        if(allowedFromAr[0] < 2000 || allowedFromAr[0] > 3000 || allowedFromAr[1] < 1 || allowedFromAr[1] > 12 || allowedFromAr[2] < 1 || allowedFromAr[2] > 31 || allowedFromAr[3] < 0 || allowedFromAr[3] > 23 || allowedFromAr[4] < 0 || allowedFromAr[4] > 59 || allowedFromAr[5] < 0 || allowedFromAr[5] > 59)
+                        {
+                            _network->publishKeypadJsonCommandResult("invalidAllowedFrom");
+                            return;
+                        }
+                    }
+                    else
+                    {
+                        _network->publishKeypadJsonCommandResult("invalidAllowedFrom");
+                        return;
+                    }
+                }
+
+                if(allowedUntil)
+                {
+                    if(strlen(allowedUntil) == 19)
+                    {
+                        String allowedUntilStr = allowedUntil;
+                        allowedUntilAr[0] = (uint16_t)allowedUntilStr.substring(0, 4).toInt();
+                        allowedUntilAr[1] = (uint8_t)allowedUntilStr.substring(5, 7).toInt();
+                        allowedUntilAr[2] = (uint8_t)allowedUntilStr.substring(8, 10).toInt();
+                        allowedUntilAr[3] = (uint8_t)allowedUntilStr.substring(11, 13).toInt();
+                        allowedUntilAr[4] = (uint8_t)allowedUntilStr.substring(14, 16).toInt();
+                        allowedUntilAr[5] = (uint8_t)allowedUntilStr.substring(17, 19).toInt();
+
+                        if(allowedUntilAr[0] < 2000 || allowedUntilAr[0] > 3000 || allowedUntilAr[1] < 1 || allowedUntilAr[1] > 12 || allowedUntilAr[2] < 1 || allowedUntilAr[2] > 31 || allowedUntilAr[3] < 0 || allowedUntilAr[3] > 23 || allowedUntilAr[4] < 0 || allowedUntilAr[4] > 59 || allowedUntilAr[5] < 0 || allowedUntilAr[5] > 59)
+                        {
+                            _network->publishKeypadJsonCommandResult("invalidAllowedUntil");
+                            return;
+                        }
+                    }
+                    else
+                    {
+                        _network->publishKeypadJsonCommandResult("invalidAllowedUntil");
+                        return;
+                    }
+                }
+
+                if(allowedFromTime)
+                {
+                    if(strlen(allowedFromTime) == 5)
+                    {
+                        String allowedFromTimeStr = allowedFromTime;
+                        allowedFromTimeAr[0] = (uint8_t)allowedFromTimeStr.substring(0, 2).toInt();
+                        allowedFromTimeAr[1] = (uint8_t)allowedFromTimeStr.substring(3, 5).toInt();
+
+                        if(allowedFromTimeAr[0] < 0 || allowedFromTimeAr[0] > 23 || allowedFromTimeAr[1] < 0 || allowedFromTimeAr[1] > 59)
+                        {
+                            _network->publishKeypadJsonCommandResult("invalidAllowedFromTime");
+                            return;
+                        }
+                    }
+                    else
+                    {
+                        _network->publishKeypadJsonCommandResult("invalidAllowedFromTime");
+                        return;
+                    }
+                }
+
+                if(allowedUntilTime)
+                {
+                    if(strlen(allowedUntilTime) == 5)
+                    {
+                        String allowedUntilTimeStr = allowedUntilTime;
+                        allowedUntilTimeAr[0] = (uint8_t)allowedUntilTimeStr.substring(0, 2).toInt();
+                        allowedUntilTimeAr[1] = (uint8_t)allowedUntilTimeStr.substring(3, 5).toInt();
+
+                        if(allowedUntilTimeAr[0] < 0 || allowedUntilTimeAr[0] > 23 || allowedUntilTimeAr[1] < 0 || allowedUntilTimeAr[1] > 59)
+                        {
+                            _network->publishKeypadJsonCommandResult("invalidAllowedUntilTime");
+                            return;
+                        }
+                    }
+                    else
+                    {
+                        _network->publishKeypadJsonCommandResult("invalidAllowedUntilTime");
+                        return;
+                    }
+                }
+
+                if(allowedWeekdays.indexOf("mon") >= 0) allowedWeekdaysInt += 64;
+                if(allowedWeekdays.indexOf("tue") >= 0) allowedWeekdaysInt += 32;
+                if(allowedWeekdays.indexOf("wed") >= 0) allowedWeekdaysInt += 16;
+                if(allowedWeekdays.indexOf("thu") >= 0) allowedWeekdaysInt += 8;
+                if(allowedWeekdays.indexOf("fri") >= 0) allowedWeekdaysInt += 4;
+                if(allowedWeekdays.indexOf("sat") >= 0) allowedWeekdaysInt += 2;
+                if(allowedWeekdays.indexOf("sun") >= 0) allowedWeekdaysInt += 1;
+            }
+
+            if(strcmp(action, "add") == 0)
+            {
+                NukiLock::NewKeypadEntry entry;
+                memset(&entry, 0, sizeof(entry));
+                size_t nameLen = strlen(name);
+                memcpy(&entry.name, name, nameLen > 20 ? 20 : nameLen);
+                entry.code = code;
+                entry.timeLimited = timeLimited == 1 ? 1 : 0;
+
+                if(allowedFrom)
+                {
+                    entry.allowedFromYear = allowedFromAr[0];
+                    entry.allowedFromMonth = allowedFromAr[1];
+                    entry.allowedFromDay = allowedFromAr[2];
+                    entry.allowedFromHour = allowedFromAr[3];
+                    entry.allowedFromMin = allowedFromAr[4];
+                    entry.allowedFromSec = allowedFromAr[5];
+                }
+
+                if(allowedUntil)
+                {
+                    entry.allowedUntilYear = allowedUntilAr[0];
+                    entry.allowedUntilMonth = allowedUntilAr[1];
+                    entry.allowedUntilDay = allowedUntilAr[2];
+                    entry.allowedUntilHour = allowedUntilAr[3];
+                    entry.allowedUntilMin = allowedUntilAr[4];
+                    entry.allowedUntilSec = allowedUntilAr[5];
+                }
+
+                entry.allowedWeekdays = allowedWeekdaysInt;
+
+                if(allowedFromTime)
+                {
+                    entry.allowedFromTimeHour = allowedFromTimeAr[0];
+                    entry.allowedFromTimeMin = allowedFromTimeAr[1];
+                }
+
+                if(allowedUntilTime)
+                {
+                    entry.allowedUntilTimeHour = allowedUntilTimeAr[0];
+                    entry.allowedUntilTimeMin = allowedUntilTimeAr[1];
+                }
+
+                result = _nukiLock.addKeypadEntry(entry);
+                Log->print("Add keypad code: ");
+                Log->println((int)result);
+            }
+            else if (strcmp(action, "update") == 0)
+            {
+                NukiLock::UpdatedKeypadEntry entry;
+                memset(&entry, 0, sizeof(entry));
+                entry.codeId = codeId;
+                size_t nameLen = strlen(name);
+                memcpy(&entry.name, name, nameLen > 20 ? 20 : nameLen);
+                entry.code = code;
+                entry.enabled = enabled == 0 ? 0 : 1;
+                entry.timeLimited = timeLimited == 1 ? 1 : 0;
+
+                if(allowedFrom)
+                {
+                    entry.allowedFromYear = allowedFromAr[0];
+                    entry.allowedFromMonth = allowedFromAr[1];
+                    entry.allowedFromDay = allowedFromAr[2];
+                    entry.allowedFromHour = allowedFromAr[3];
+                    entry.allowedFromMin = allowedFromAr[4];
+                    entry.allowedFromSec = allowedFromAr[5];
+                }
+
+                if(allowedUntil)
+                {
+                    entry.allowedUntilYear = allowedUntilAr[0];
+                    entry.allowedUntilMonth = allowedUntilAr[1];
+                    entry.allowedUntilDay = allowedUntilAr[2];
+                    entry.allowedUntilHour = allowedUntilAr[3];
+                    entry.allowedUntilMin = allowedUntilAr[4];
+                    entry.allowedUntilSec = allowedUntilAr[5];
+                }
+
+                entry.allowedWeekdays = allowedWeekdaysInt;
+
+                if(allowedFromTime)
+                {
+                    entry.allowedFromTimeHour = allowedFromTimeAr[0];
+                    entry.allowedFromTimeMin = allowedFromTimeAr[1];
+                }
+
+                if(allowedUntilTime)
+                {
+                    entry.allowedUntilTimeHour = allowedUntilTimeAr[0];
+                    entry.allowedUntilTimeMin = allowedUntilTimeAr[1];
+                }
+
+                result = _nukiLock.updateKeypadEntry(entry);
+                Log->print("Update keypad code: ");
+                Log->println((int)result);
+            }
+        }
+        else
+        {
+            _network->publishKeypadJsonCommandResult("invalidAction");
+            return;
+        }
+
+        updateKeypad();
+
+        if((int)result != -1)
+        {
+            char resultStr[15];
+            memset(&resultStr, 0, sizeof(resultStr));
+            NukiLock::cmdResultToString(result, resultStr);
+            _network->publishKeypadJsonCommandResult(resultStr);
+        }
+    }
+    else
+    {
+        _network->publishKeypadJsonCommandResult("noActionSet");
+        return;
+    }
+}
+
 const NukiLock::KeyTurnerState &NukiWrapper::keyTurnerState()
 {
     return _keyTurnerState;

NukiWrapper.h

@@ -27,7 +27,7 @@ public:
     bool isPinSet();
     void setPin(const uint16_t pin);
     void unpair();
-    
+
     void disableHASS();
 
     void disableWatchdog();
@@ -47,10 +47,12 @@ private:
     static LockActionResult onLockActionReceivedCallback(const char* value);
     static void onConfigUpdateReceivedCallback(const char* value);
     static void onKeypadCommandReceivedCallback(const char* command, const uint& id, const String& name, const String& code, const int& enabled);
+    static void onKeypadJsonCommandReceivedCallback(const char* value);
     static void gpioActionCallback(const GpioAction& action, const int& pin);
     void onKeypadCommandReceived(const char* command, const uint& id, const String& name, const String& code, const int& enabled);
     void onConfigUpdateReceived(const char* value);
-    
+    void onKeypadJsonCommandReceived(const char* value);
+
     void updateKeyTurnerState();
     void updateBatteryState();
     void updateConfig();
@@ -62,7 +64,7 @@ private:
 
     void readConfig();
     void readAdvancedConfig();
-    
+
     void setupHASS();
 
     void printCommandResult(Nuki::CmdResult result);

README.md

@@ -80,7 +80,7 @@ Enable "Register as app" before pairing to allow this. Otherwise the Bridge will
 ## Support
 
 If you haven't ordered your Nuki product yet, you can support me by using my referrer code when placing your order:<br>
-REFVSU6HN9HWK<br>
+REFNW2959GXR7<br>
 This will also give you a 10% discount on your order.<br>
 <br>
 This project is free to use for everyone. However if you feel like donating, you can buy me a coffee at ko-fi.com:<br>
@@ -284,6 +284,7 @@ In a browser navigate to the IP address assigned to the ESP32.
 ## Changing Nuki Lock/Opener Configuration
 
 To change Nuki Lock/Opener settings set the `configuration/action` topic to a JSON formatted value with any of the following settings. Multiple settings can be changed at once. See [Nuki Smart Lock API Basic Config](https://developer.nuki.io/page/nuki-smart-lock-api-2/2/#heading--set-config), [Nuki Smart Lock API Advanced Config](https://developer.nuki.io/page/nuki-smart-lock-api-2/2/#heading--advanced-config), [Nuki Opener API Basic Config](https://developer.nuki.io/page/nuki-opener-api-1/7/#heading--set-config) and [Nuki Opener API Advanced Config](https://developer.nuki.io/page/nuki-opener-api-1/7/#heading--advanced-config) for more information on the available settings.<br>
+Changing settings has to enabled first in the configuration portal. Check the settings you want to be able to change under "Nuki Lock/Opener Config Control" in "Access Level Configuration" and save the configuration.
 
 ### Nuki Lock Configuration
 
@@ -419,13 +420,48 @@ The following mapping between Home Assistant services and Nuki commands is setup
 NOTE: MQTT Discovery uses retained MQTT messages to store devices configurations. In order to avoid orphan configurations on your broker please disable autodiscovery first if you no longer want to use this software. Retained messages are automatically cleared when unpairing and when changing/disabling autodiscovery topic in MQTT Configuration page.<br>
 NOTE2: Home Assistant can be setup manually using the [MQTT Lock integration](https://www.home-assistant.io/integrations/lock.mqtt/), but this is not recommended
 
-## Keypad control (optional)
+## Keypad control using JSON (optional)
+
+If a keypad is connected to the lock, keypad codes can be added, updated and removed. This has to enabled first in the configuration portal. Check "Add, modify and delete keypad codes" under "Access Level Configuration" and save the configuration.
+
+Information about current keypad codes is published as JSON data to the "keypad/json" MQTT topic.<br>
+This needs to be enabled separately by checking "Publish keypad codes information" under "Access Level Configuration" and saving the configuration.
+For security reasons, the code itself is not published.
+
+To change Nuki Lock/Opener keypad settings set the `keypad/actionJson` topic to a JSON formatted value containing the following nodes.
+
+| Node             | Delete   | Add      | Update   | Usage                                                                                    | Possible values                                                |
+|------------------|----------|----------|----------|------------------------------------------------------------------------------------------|----------------------------------------------------------------|
+| action           | Required | Required | Required | The action to execute                                                                    | "delete", "add", "update"                                      |
+| codeId           | Required | Not used | Required | The code ID of the existing code to delete or update                                     | Integer                                                        |
+| code             | Not used | Required | Required | The code to create or update                                                             | 6-digit Integer without zero's                                 |
+| enabled          | Not used | Not used | Optional | Enable or disable the code, enabled if not set                                           | 1 = enabled, 0 = disabled                                      |
+| name             | Not used | Required | Required | The name of the code to create or update                                                 | String, max 20 chars                                           |
+| timeLimited      | Not used | Optional | Optional | If this authorization is restricted to access only at certain times, disabled if not set | 1 = enabled, 0 = disabled                                      |
+| allowedFrom      | Not used | Optional | Optional | The start timestamp from which access should be allowed (requires timeLimited = 1)       | "YYYY-MM-DD HH:MM:SS"                                          |
+| allowedUntil     | Not used | Optional | Optional | The end timestamp until access should be allowed (requires timeLimited = 1)              | "YYYY-MM-DD HH:MM:SS"                                          |
+| allowedWeekdays  | Not used | Optional | Optional | Allowed weekdays on which access should be allowed (requires timeLimited = 1)            | Array of days: "mon", "tue", "wed", "thu" , "fri" "sat", "sun" |
+| allowedFromTime  | Not used | Optional | Optional | The start time per day from which access should be allowed (requires timeLimited = 1)    | "HH:MM"                                                        |
+| allowedUntilTime | Not used | Optional | Optional | The end time per day until access should be allowed (requires timeLimited = 1)           | "HH:MM"                                                        |
+
+Example usage:<br>
+Examples:
+- Delete: `{ "action": "delete", "codeId": "1234" }`
+- Add: `{ "action": "add", "code": "589472", "name": "Test", "timeLimited": "1", "allowedFrom": "2024-04-12 10:00:00", "allowedUntil": "2034-04-12 10:00:00", "allowedWeekdays": [ "wed", "thu", "fri" ], "allowedFromTime": "08:00", "allowedUntilTime": "16:00" }`
+- Update: `{ "action": "update", "codeId": "1234", "code": "589472", "enabled": "1", "name": "Test", "timeLimited": "1", "allowedFrom": "2024-04-12 10:00:00", "allowedUntil": "2034-04-12 10:00:00", "allowedWeekdays": [ "mon", "tue", "sat", "sun" ], "allowedFromTime": "08:00", "allowedUntilTime": "16:00" }`
+
+### Result of attempted keypad code changes
+
+The result of the last configuration change action will be published to the `configuration/commandResultJson` MQTT topic.<br>
+Possible values are "noPinSet", "keypadControlDisabled", "keypadNotAvailable", "keypadDisabled", "invalidConfig", "invalidJson", "noActionSet", "invalidAction", "noExistingCodeIdSet", "noNameSet", "noValidCodeSet", "noCodeSet", "invalidAllowedFrom", "invalidAllowedUntil", "invalidAllowedFromTime", "invalidAllowedUntilTime", "success", "failed", "timeOut", "working", "notPaired", "error" and "undefined".<br>
+ 
+## Keypad control (alternative, optional)
 
 If a keypad is connected to the lock, keypad codes can be added, updated and removed.
-This has to enabled first in the configuration portal. Check "Enable keypad control via MQTT" and save the configuration.
-After enabling keypad control, information about codes is published under "keypad/code_x", x starting from 0 up the number of configured codes. 
-The same data is also published as JSON data to the "keypad/json" MQTT topic.
-<br>
+This has to enabled first in the configuration portal. Check "Add, modify and delete keypad codes" under "Access Level Configuration" and save the configuration.
+
+Information about codes is published under "keypad/code_x", x starting from 0 up the number of configured codes. This needs to be enabled separately by checking "Publish keypad codes information" under "Access Level Configuration" and saving the configuration.
+
 For security reasons, the code itself is not published. To modify keypad codes, a command
 structure is setup under keypad/command: