Subversion Repositories HomeAutomation

Rev

Rev 2052 | Rev 2067 | Go to most recent revision | 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"];
  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.                         text += data+"="+last_value[type_name][data]+" ";
  467.                     }
  468.                 }
  469.                 Log("\033[96m" + type_name + ": \033[0;1m" + text + "\033[0m at " + date.toString() + "\n");
  470.             }
  471.         }
  472.         else
  473.         {
  474.             Log("\033[32mNo value is stored for " + name + ".\033[0m\n");
  475.         }
  476.        
  477.         found = true;
  478.     }
  479.    
  480.     if (!found)
  481.     {
  482.         Log("\033[31mNo aliases by the name " + alias_name + " were applicable for this command.\033[0m\n");
  483.         return false;
  484.     }
  485.    
  486.     return true;
  487. }
  488. Console_RegisterCommand(Module_GetLastData, function(arg_index, args) { return Console_StandardAutocomplete(arg_index, args, Module_GetAliasNames()); });
  489.  
  490. function Module_GetLastDataRaw(alias_name)
  491. {
  492.     var result = {};
  493.  
  494.     if (arguments.length < 1)
  495.     {
  496.         result.error = true;
  497.     }
  498.     else
  499.     {
  500.       var aliases_data = Module_ResolveAlias(alias_name);
  501.       var found = false;
  502.    
  503.       result.results = {};
  504.      
  505.       for (var name in aliases_data)
  506.       {
  507.         var last_value_string = Storage_GetParameter("LastValues", name);
  508.        
  509.         if (last_value_string)
  510.         {
  511.            result.results[name] = JSON.parse(last_value_string);
  512.         }
  513.         else
  514.         {
  515.           result.results[name] = {};
  516.         }
  517.     }
  518.     }
  519.    
  520.     Log(JSON.stringify(result)+'\n');
  521.     return true;
  522. }
  523. Console_RegisterCommand(Module_GetLastDataRaw, function(arg_index, args) { return Console_StandardAutocomplete(arg_index, args, Module_GetAliasNames()); });
  524.  
  525.