Subversion Repositories HomeAutomation

Rev

Rev 2138 | Blame | Compare with Previous | Last modification | View Log | SVN | RSS feed

  1.  
  2. Require("plugin/storage.js");
  3.  
  4. function Module_CreateAliasAutoComplete(arg_index, args)
  5. {
  6.     if (arg_index == 0)
  7.     {
  8.         return Module_GetAliasNames();
  9.     }
  10.     else if (arg_index == 1)
  11.     {
  12.         return Module_GetNames();
  13.     }
  14.     else if (arg_index == 2)
  15.     {
  16.         return Module_GetAvailableIds([ args[1] ])
  17.     }
  18.  
  19.     return [];
  20. }
  21.  
  22. function Module_CreateAlias(alias_name, module_name, module_id, specific)
  23. {
  24.     if (arguments.length < 3)
  25.     {
  26.         Log("\033[31mNot enough parameters given.\033[0m\n");
  27.         return false;
  28.     }
  29.  
  30.     if (alias_name == "all")
  31.     {
  32.         Log("\033[31m\"all\" is not allowed as alias name.\033[0m\n");
  33.         return false;
  34.     }
  35.  
  36.     var specific_list = {};
  37.  
  38.     if (specific)
  39.     {
  40.         var specific_parts = specific.split(",");
  41.  
  42.         // TODO: Check length
  43.  
  44.         for (var index in specific_parts)
  45.         {
  46.             var parts = specific_parts[index].split("=");
  47.  
  48.             // TODO: Check length
  49.  
  50.             specific_list[parts[0]] = parts[1];
  51.         }
  52.     }
  53.  
  54.     var alias_data = {
  55.         "group"       : false,
  56.         "name"        : alias_name,
  57.         "module_name" : module_name,
  58.         "module_id"   : module_id,
  59.         "specific"    : specific_list
  60.     };
  61.  
  62.     return Storage_SetParameter("alias", alias_name, JSON.stringify(alias_data));
  63. }
  64. Console_RegisterCommand(Module_CreateAlias, Module_CreateAliasAutoComplete);
  65.  
  66. function Module_CreateAliasGroupAutoComplete(arg_index, args)
  67. {
  68.     if (arg_index == 0)
  69.     {
  70.         return Module_GetAliasNames();
  71.     }
  72.     else if (arg_index == 1)
  73.     {
  74.         return Module_GetNames();
  75.     }
  76.     else if (arg_index >= 2)
  77.     {
  78.         return Module_GetAliasNames([ args[1] ])
  79.     }
  80.  
  81.     return [];
  82. }
  83.  
  84. function Module_CreateAliasGroup(alias_group_name, module_type, alias_name1, alias_name2)
  85. {
  86.     if (arguments.length < 3)
  87.     {
  88.         Log("\033[31mNot enough parameters given.\033[0m\n");
  89.         return false;
  90.     }
  91.  
  92.     if (alias_group_name == "all")
  93.     {
  94.         Log("\033[31m\"all\" is not allowed as alias name.\033[0m\n");
  95.         return false;
  96.     }
  97.  
  98.     alias_group_name = arguments[0];
  99.     module_type = arguments[1];
  100.     var aliases = [];
  101.  
  102.     for (var n = 2; n < arguments.length; n++)
  103.     {
  104.         if (arguments[n].length > 0)
  105.         {
  106.             var aliases_data = Module_ResolveAlias(arguments[n]);
  107.             aliases.push(arguments[n]);
  108.         }
  109.     }
  110.  
  111.     if (aliases.length == 0)
  112.     {
  113.         Log("\033[31mNo valid aliases were found, aborting creation of group alias.\033[0m\n");
  114.         return false;
  115.     }
  116.  
  117.     var alias_data = {
  118.         "group"       : true,
  119.         "name"        : alias_group_name,
  120.         "module_name" : module_type,
  121.         "aliases"     : aliases
  122.     };
  123.  
  124.     return Storage_SetParameter("alias", alias_group_name, JSON.stringify(alias_data));
  125. }
  126. Console_RegisterCommand(Module_CreateAliasGroup, Module_CreateAliasGroupAutoComplete);
  127.  
  128. function Module_ResolveAlias(alias_name, filter_module_names)
  129. {
  130.     var aliases_data = {};
  131.     var alias_data_string = Storage_GetParameter("alias", alias_name);
  132.  
  133.     if (alias_data_string)
  134.     {
  135.         var alias_data = eval("(" + alias_data_string + ")");
  136.  
  137.         if (alias_data["group"])
  138.         {
  139.             for (var n in alias_data["aliases"])
  140.             {
  141.                 var aliases_data_sub = Module_ResolveAlias(alias_data["aliases"][n], filter_module_names);
  142.  
  143.                 for (var name in aliases_data_sub)
  144.                 {
  145.                     aliases_data[name] = aliases_data_sub[name];
  146.                 }
  147.             }
  148.         }
  149.         else
  150.         {
  151.             if (!filter_module_names || in_array(filter_module_names, alias_data["module_name"]))
  152.             {
  153.                 aliases_data[alias_name] = alias_data;
  154.             }
  155.         }
  156.     }
  157.  
  158.     return aliases_data;
  159. }
  160.  
  161. function Module_LookupAliases(match_filter)
  162. {
  163.     var aliases_data_filtered = {};
  164.     var aliases_data = Storage_GetParameters("alias");
  165.  
  166.     for (var name in aliases_data)
  167.     {
  168.         var alias_data = eval("(" + aliases_data[name] + ")");
  169.  
  170.         var valid = true;
  171.  
  172.         for (var key in match_filter)
  173.         {
  174.             if (alias_data[key] != match_filter[key])
  175.             {
  176.                 valid = false;
  177.                 break;
  178.             }
  179.         }
  180.  
  181.         if (valid)
  182.         {
  183.             aliases_data_filtered[name] = alias_data;
  184.         }
  185.     }
  186.  
  187.     return aliases_data_filtered;
  188. }
  189.  
  190. function Module_GetAliasNames(filter_module_names)
  191. {
  192.     var aliases_name_filtered = [];
  193.     var aliases_data = Storage_GetParameters("alias");
  194.  
  195.     for (var name in aliases_data)
  196.     {
  197.         var alias_data = eval("(" + aliases_data[name] + ")");
  198.  
  199.         if (!filter_module_names || in_array(filter_module_names, alias_data["module_name"]))
  200.         {
  201.             aliases_name_filtered.push(name)
  202.         }
  203.     }
  204.  
  205.     return aliases_name_filtered;
  206. }
  207.  
  208. function Module_GetAvailableIds(filter_module_names)
  209. {
  210.     var result_list = [];
  211.     var available_modules = ModuleExport_GetAvailableModules();
  212.  
  213.     for (var n in available_modules)
  214.     {
  215.         var id_parts = available_modules[n].split(":", 2);
  216.  
  217.         if (in_array(filter_module_names, id_parts[0]))
  218.         {
  219.             result_list.push(id_parts[1]);
  220.         }
  221.     }
  222.  
  223.     return result_list;
  224. }
  225.  
  226. function Module_GetNames()
  227. {
  228.     return [ "Dimmer230", "irTransmit", "irReceive", "SimpleDTMF", "BusVoltage", "DS18x20", "FOST02", "HD44789", "Rotary", "RotaryHex", "Touch", "power", "input", "output", "softPWM", "counter", "rfTransceive", "hwPWM", "KS0108", "heatPower", "water"];
  229. }
  230.  
  231. function Module_SendMessage(module_name, module_id, command, variables)
  232. {
  233.     var args = [];
  234.  
  235.     args.push(module_name + ":" + module_id);
  236.     args.push(command);
  237.  
  238.     var length = 0;
  239.     for (var key in variables)
  240.     {
  241.         length++;
  242.     }
  243.  
  244.     args.push(length);
  245.  
  246.     for (var key in variables)
  247.     {
  248.         args.push(key);
  249.         args.push(variables[key]);
  250.     }
  251.  
  252.     return ModuleExport_SendMessage.apply(null, Array.prototype.slice.call(args, 0));
  253. }
  254.  
  255. var Module_OnChangeFunctions = {};
  256. var Module_OnMessageFunctions = {};
  257.  
  258. function Module_RegisterToOnChange(alias_name, callback)
  259. {
  260.     if (!Module_OnChangeFunctions[alias_name])
  261.     {
  262.         Module_OnChangeFunctions[alias_name] = [];
  263.     }
  264.  
  265.     Module_OnChangeFunctions[alias_name].push(callback);
  266. }
  267.  
  268. function Module_RegisterToOnMessage(alias_name, callback)
  269. {
  270.     if (!Module_OnMessageFunctions[alias_name])
  271.     {
  272.         Module_OnMessageFunctions[alias_name] = [];
  273.     }
  274.  
  275.     Module_OnMessageFunctions[alias_name].push(callback);
  276. }
  277.  
  278. function Module_OnMessage(full_id, command, variables)
  279. {
  280.     var id_parts = full_id.split(":", 2);
  281.     var aliases_data = {};
  282.  
  283.     var aliases_data = Module_LookupAliases({
  284.         "module_name" : id_parts[0],
  285.         "module_id"   : id_parts[1],
  286.         "group"       : false
  287.     });
  288.  
  289.     for (var alias_name in aliases_data)
  290.     {
  291.         var ok = true;
  292.  
  293.         if (aliases_data[alias_name]["specific"])
  294.         {
  295.             var ok = true;
  296.  
  297.             for (var name in variables)
  298.             {
  299.                 if (aliases_data[alias_name]["specific"][name] && aliases_data[alias_name]["specific"][name] != variables[name])
  300.                 {
  301.                     ok = false;
  302.                     break;
  303.                 }
  304.             }
  305.         }
  306.  
  307.         if (Module_OnMessageFunctions[alias_name] && ok)
  308.         {
  309.             for (var n in Module_OnMessageFunctions[alias_name])
  310.             {
  311.                 Module_OnMessageFunctions[alias_name][n](alias_name, command, variables);
  312.             }
  313.         }
  314.     }
  315.  
  316.     if (Module_OnMessageFunctions["all"])
  317.     {
  318.         for (var n in Module_OnMessageFunctions["all"])
  319.         {
  320.             Module_OnMessageFunctions["all"][n](id_parts[0], id_parts[1], command, variables);
  321.         }
  322.     }
  323. }
  324.  
  325. function Module_OnChange(full_id, available)
  326. {
  327.     var id_parts = full_id.split(":", 2);
  328.     var aliases_data = {};
  329.  
  330.     aliases_data = Module_LookupAliases({
  331.         "module_name" : id_parts[0],
  332.         "module_id"   : id_parts[1],
  333.         "group"       : false
  334.     });
  335.     for (var alias_name in aliases_data)
  336.     {
  337.         var ok = true;
  338.  
  339.         if (Module_OnChangeFunctions[alias_name])
  340.         {
  341.             for (var n in Module_OnChangeFunctions[alias_name])
  342.             {
  343.                 Module_OnChangeFunctions[alias_name][n](alias_name, available);
  344.             }
  345.         }
  346.     }
  347.  
  348.     if (Module_OnChangeFunctions["all"])
  349.     {
  350.         for (var n in Module_OnChangeFunctions["all"])
  351.         {
  352.             Module_OnChangeFunctions["all"][n](id_parts[0], id_parts[1], available);
  353.         }
  354.     }
  355. }
  356.  
  357. function Module_GetLastValue(alias_name)
  358. {
  359.     if (arguments.length < 1)
  360.     {
  361.         Log("\033[31mNot enough parameters given.\033[0m\n");
  362.         return false;
  363.     }
  364.  
  365.     var aliases_data = Module_ResolveAlias(alias_name);
  366.     var found = false;
  367.  
  368.     for (var name in aliases_data)
  369.     {
  370.         var last_value_string = Storage_GetParameter("LastValues", name);
  371.  
  372.         if (last_value_string)
  373.         {
  374.             Log("\033[0;1mStored values for " + name + ":\033[0m\n");
  375.             var last_value = eval("(" + last_value_string + ")");
  376.  
  377.             for (var type_name in last_value)
  378.             {
  379.                 var date = new Date(last_value[type_name]["timestamp"] * 1000);
  380.  
  381.                 Log("\033[96m" + type_name + ": \033[0;1m" + last_value[type_name]["value"] + "\033[0m at " + date.toString() + "\n");
  382.             }
  383.         }
  384.         else
  385.         {
  386.             Log("\033[32mNo value is stored for " + name + ".\033[0m\n");
  387.         }
  388.  
  389.         found = true;
  390.     }
  391.  
  392.     if (!found)
  393.     {
  394.         Log("\033[31mNo aliases by the name " + alias_name + " were applicable for this command.\033[0m\n");
  395.         return false;
  396.     }
  397.  
  398.     return true;
  399. }
  400. Console_RegisterCommand(Module_GetLastValue, function(arg_index, args) { return Console_StandardAutocomplete(arg_index, args, Module_GetAliasNames()); });
  401.  
  402. function Module_ListAvailable()
  403. {
  404.     var available_modules = ModuleExport_GetAvailableModules();
  405.  
  406.     var lines = [["Id", "Name", "Aliases"]];
  407.  
  408.     for (var n in available_modules)
  409.     {
  410.         var id_parts = available_modules[n].split(":", 2);
  411.         var alias = "<none>";
  412.  
  413.         var alias_names = get_keys(Module_LookupAliases({
  414.             "module_name" : id_parts[0],
  415.             "module_id"   : id_parts[1],
  416.             "group"       : false
  417.         }));
  418.  
  419.         if (alias_names.length > 0)
  420.         {
  421.             alias = alias_names.join(", ");
  422.         }
  423.  
  424.         lines.push([id_parts[1], id_parts[0], alias]);
  425.     }
  426.  
  427.     var table_lines = create_table(lines);
  428.  
  429.     Log("\033[29;1m" + table_lines[0] + "\033[0m\n");
  430.  
  431.     for (var n = 1; n < table_lines.length; n++)
  432.     {
  433.         Log(table_lines[n] + "\n");
  434.     }
  435.  
  436.     return true;
  437. }
  438. Console_RegisterCommand(Module_ListAvailable);
  439.  
  440. function Module_GetLastData(alias_name)
  441. {
  442.     if (arguments.length < 1)
  443.     {
  444.         Log("\033[31mNot enough parameters given.\033[0m\n");
  445.         return false;
  446.     }
  447.  
  448.     var aliases_data = Module_ResolveAlias(alias_name);
  449.     var found = false;
  450.  
  451.     for (var name in aliases_data)
  452.     {
  453.         var last_value_string = Storage_GetParameter("LastValues", name);
  454.  
  455.         if (last_value_string)
  456.         {
  457.             Log("\033[0;1mStored values for " + name + ":\033[0m\n");
  458.             var last_value = eval("(" + last_value_string + ")");
  459.             for (var type_name in last_value)
  460.             {
  461.                 var date = new Date(last_value[type_name]["timestamp"] * 1000);
  462.                 var text = "";
  463.                 for (var data in last_value[type_name])
  464.                 {
  465.                     if (data != "timestamp"){
  466.                         if (typeof last_value[type_name][data] == "string")
  467.                         {
  468.                             text += data+"="+last_value[type_name][data]+" ";
  469.                         }
  470.                         else
  471.                         {
  472.                             for (var name2 in last_value[type_name][data])
  473.                             {
  474.                               text += name2 + "=" + last_value[type_name][data][name2] + " ";
  475.                             }
  476.                         }
  477.                     }
  478.                    
  479.                 }
  480.                 Log("\033[96m" + type_name + ": \033[0;1m" + text + "\033[0m at " + date.toString() + "\n");
  481.                
  482.                
  483.                 /* Check if the value is simple or complex */
  484.            
  485.                
  486.                
  487.                
  488.                
  489.             }
  490.         }
  491.         else
  492.         {
  493.             Log("\033[32mNo value is stored for " + name + ".\033[0m\n");
  494.         }
  495.  
  496.         found = true;
  497.     }
  498.  
  499.     if (!found)
  500.     {
  501.         Log("\033[31mNo aliases by the name " + alias_name + " were applicable for this command.\033[0m\n");
  502.         return false;
  503.     }
  504.  
  505.     return true;
  506. }
  507. Console_RegisterCommand(Module_GetLastData, function(arg_index, args) { return Console_StandardAutocomplete(arg_index, args, Module_GetAliasNames()); });
  508.  
  509. function Module_GetLastDataNative(alias_name)
  510. {
  511.   var result = { };
  512.  
  513.   for (var n = 0; n < arguments.length; n++)
  514.   {
  515.     var aliases_data = Module_ResolveAlias(arguments[n]);
  516.  
  517.     result[arguments[n]] = {};
  518.  
  519.     for (var name in aliases_data)
  520.     {
  521.       var last_value_string = Storage_GetParameter("LastValues", name);
  522.  
  523.       if (last_value_string)
  524.       {
  525.         result[name] = JSON.parse(last_value_string);
  526.         result[arguments[n]] = result[name];
  527.       }
  528.       else
  529.       {
  530.         result[name] = {};
  531.       }
  532.     }
  533.   }
  534.  
  535.   return result;
  536. }
  537.  
  538. function Module_GetLastDataRaw(alias_name)
  539. {
  540.     var result = { results : {} };
  541.  
  542.   for (var n = 0; n < arguments.length; n++)
  543.     {
  544.       var aliases_data = Module_ResolveAlias(arguments[n]);
  545.  
  546.       for (var name in aliases_data)
  547.       {
  548.           var last_value_string = Storage_GetParameter("LastValues", name);
  549.  
  550.       result[arguments[n]] = {};
  551.  
  552.           if (last_value_string)
  553.           {
  554.             result.results[name] = JSON.parse(last_value_string);
  555.         result[arguments[n]] = result[name];
  556.           }
  557.           else
  558.           {
  559.             result.results[name] = {};
  560.           }
  561.     }
  562.     }
  563.  
  564.     Log(JSON.stringify(result)+'\n');
  565.     return true;
  566. }
  567. Console_RegisterCommand(Module_GetLastDataRaw, function(arg_index, args) { return Console_StandardAutocomplete(arg_index, args, Module_GetAliasNames()); });
  568.  
  569.