Subversion Repositories HomeAutomation

Rev

Rev 1660 | Rev 1926 | 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" ];
  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.     var aliases_data_all = Module_LookupAliases({
  331.         "module_name" : id_parts[0],
  332.         "module_id"   : id_parts[1],
  333.         "group"       : false
  334.     });
  335.    
  336.     for (var alias_name in aliases_data)
  337.     {
  338.         var ok = true;
  339.        
  340.         if (aliases_data[alias_name]["specific"])
  341.         {
  342.             var ok = true;
  343.            
  344.             for (var name in variables)
  345.             {
  346.                 if (aliases_data[alias_name]["specific"][name] && aliases_data[alias_name]["specific"][name] != variables[name])
  347.                 {
  348.                     ok = false;
  349.                     break;
  350.                 }
  351.             }
  352.         }
  353.        
  354.         if (Module_OnChangeFunctions[alias_name] && ok)
  355.         {
  356.             for (var n in Module_OnChangeFunctions[alias_name])
  357.             {
  358.                 Module_OnChangeFunctions[alias_name][n](alias_name, available);
  359.             }
  360.         }
  361.     }
  362.    
  363.     if (Module_OnChangeFunctions["all"])
  364.     {
  365.         for (var n in Module_OnChangeFunctions["all"])
  366.         {
  367.             Module_OnChangeFunctions["all"][n](id_parts[0], id_parts[1], available);
  368.         }
  369.     }
  370. }
  371.  
  372. function Module_GetLastValue(alias_name)
  373. {
  374.     if (arguments.length < 1)
  375.     {
  376.         Log("\033[31mNot enough parameters given.\033[0m\n");
  377.         return false;
  378.     }
  379.    
  380.     var aliases_data = Module_ResolveAlias(alias_name);
  381.     var found = false;
  382.    
  383.     for (var name in aliases_data)
  384.     {
  385.         var last_value_string = Storage_GetParameter("LastValues", name);
  386.        
  387.         if (last_value_string)
  388.         {
  389.             Log("\033[0;1mStored values for " + name + ":\033[0m\n");
  390.             var last_value = eval("(" + last_value_string + ")");
  391.            
  392.             for (var type_name in last_value)
  393.             {
  394.                 var date = new Date(last_value[type_name]["timestamp"] * 1000);
  395.                
  396.                 Log("\033[96m" + type_name + ": \033[0;1m" + last_value[type_name]["value"] + "\033[0m at " + date.toString() + "\n");
  397.             }
  398.         }
  399.         else
  400.         {
  401.             Log("\033[32mNo value is stored for " + name + ".\033[0m\n");
  402.         }
  403.        
  404.         found = true;
  405.     }
  406.    
  407.     if (!found)
  408.     {
  409.         Log("\033[31mNo aliases by the name " + alias_name + " were applicable for this command.\033[0m\n");
  410.         return false;
  411.     }
  412.    
  413.     return true;
  414. }
  415. Console_RegisterCommand(Module_GetLastValue, function(arg_index, args) { return Console_StandardAutocomplete(arg_index, args, Module_GetAliasNames()); });
  416.  
  417. function Module_ListAvailable()
  418. {
  419.     var available_modules = ModuleExport_GetAvailableModules();
  420.    
  421.     var lines = [["Id", "Name", "Aliases"]];
  422.    
  423.     for (var n in available_modules)
  424.     {
  425.         var id_parts = available_modules[n].split(":", 2);
  426.         var alias = "<none>";
  427.        
  428.         var alias_names = get_keys(Module_LookupAliases({
  429.             "module_name" : id_parts[0],
  430.             "module_id"   : id_parts[1],
  431.             "group"       : false
  432.         }));
  433.        
  434.         if (alias_names.length > 0)
  435.         {
  436.             alias = alias_names.join(", ");
  437.         }
  438.        
  439.         lines.push([id_parts[1], id_parts[0], alias]);
  440.     }
  441.    
  442.     var table_lines = create_table(lines);
  443.    
  444.     Log("\033[29;1m" + table_lines[0] + "\033[0m\n");
  445.    
  446.     for (var n = 1; n < table_lines.length; n++)
  447.     {
  448.         Log(table_lines[n] + "\n");
  449.     }
  450.    
  451.     return true;
  452. }
  453. Console_RegisterCommand(Module_ListAvailable);
  454.