Subversion Repositories HomeAutomation

Rev

Rev 1646 | Rev 1648 | 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(args)
  5. {
  6.     // args[0] == command name
  7.     var arg_index = args.length - 2;
  8.    
  9.     if (arg_index == 0)
  10.     {
  11.         return Module_GetAliasNames();
  12.     }
  13.     else if (arg_index == 1)
  14.     {
  15.         return Module_GetNames();
  16.     }
  17.     else if (arg_index == 2)
  18.     {
  19.         return Module_GetAvailableIds([ args[2] ])
  20.     }
  21.    
  22.     return [];
  23. }
  24.  
  25. function Module_CreateAlias(alias_name, module_name, module_id, specific)
  26. {
  27.     // TODO Check arguments
  28.    
  29.     var specific_list = {};
  30.    
  31.     if (specific)
  32.     {
  33.         var specific_parts = split(",", specific);
  34.        
  35.         // TODO: Check length
  36.        
  37.         for (var index in specific_parts)
  38.         {
  39.             var parts = split("=", specific_parts[index]);
  40.            
  41.             // TODO: Check length
  42.            
  43.             specific_list[parts[0]] = parts[1];
  44.         }
  45.     }
  46.    
  47.     var alias_data = {
  48.         "group"       : false,
  49.         "name"        : alias_name,
  50.         "module_name" : module_name,
  51.         "module_id"   : module_id,
  52.         "specific"    : specific_list
  53.     };
  54.    
  55.     return Storage_SetParameter("alias", alias_name, JSON.stringify(alias_data));
  56. }
  57. Console_RegisterCommand(Module_CreateAlias, Module_CreateAliasAutoComplete);
  58.  
  59. function Module_CreateAliasGroupAutoComplete(args)
  60. {
  61.     // args[0] == command name
  62.     var arg_index = args.length - 2;
  63.    
  64.     if (arg_index == 0)
  65.     {
  66.         return Module_GetAliasNames();
  67.     }
  68.     else if (arg_index == 1)
  69.     {
  70.         return Module_GetNames();
  71.     }
  72.     else if (arg_index >= 2)
  73.     {
  74.         return Module_GetAliasNames([ args[2] ])
  75.     }
  76.    
  77.     return [];
  78. }
  79.  
  80. function Module_CreateAliasGroup(alias_group_name, module_type, alias_name1, alias_name2)
  81. {
  82.     if (arguments.length < 3)
  83.     {
  84.         throw("Not enought parameters given");
  85.     }
  86.    
  87.     alias_group_name = arguments[0];
  88.     module_type = arguments[1];
  89.     var aliases = [];
  90.    
  91.     for (var n = 2; n < arguments.length; n++)
  92.     {
  93.         if (arguments[n].length > 0)
  94.         {
  95.             var aliases_data = Module_ResolveAlias(arguments[n]);
  96.             aliases.push(arguments[n]);
  97.         }
  98.     }
  99.    
  100.     if (aliases.length == 0)
  101.     {
  102.         throw("No valid aliases were found, aborting creation of group alias");
  103.     }
  104.    
  105.     var alias_data = {
  106.         "group"       : true,
  107.         "name"        : alias_group_name,
  108.         "module_name" : module_type,
  109.         "aliases"     : aliases
  110.     };
  111.    
  112.     return Storage_SetParameter("alias", alias_group_name, JSON.stringify(alias_data));
  113. }
  114. Console_RegisterCommand(Module_CreateAliasGroup, Module_CreateAliasGroupAutoComplete);
  115.  
  116. function Module_ResolveAlias(alias_name, filter_module_names)
  117. {
  118.     var aliases_data = {};
  119.     var alias_data_string = Storage_GetParameter("alias", alias_name);
  120.    
  121.     if (alias_data_string)
  122.     {
  123.         var alias_data = eval("(" + alias_data_string + ")");
  124.        
  125.         if (alias_data["group"])
  126.         {
  127.             for (var n in alias_data["aliases"])
  128.             {
  129.                 var aliases_data_sub = Module_ResolveAlias(alias_data["aliases"][n], filter_module_names);
  130.                
  131.                 for (var name in aliases_data_sub)
  132.                 {
  133.                     aliases_data[name] = aliases_data_sub[name];
  134.                 }
  135.             }
  136.         }
  137.         else
  138.         {
  139.             if (in_array(filter_module_names, alias_data["module_name"]))
  140.             {
  141.                 aliases_data[alias_name] = alias_data;
  142.             }
  143.         }
  144.     }
  145.    
  146.     return aliases_data;
  147. }
  148.  
  149. function Module_LookupAliases(match_filter)
  150. {
  151.     var aliases_data_filtered = {};
  152.     var aliases_data = Storage_GetParameters("alias");
  153.    
  154.     for (var name in aliases_data)
  155.     {
  156.         var alias_data = eval("(" + aliases_data[name] + ")");
  157.        
  158.         var valid = true;
  159.        
  160.         for (var key in match_filter)
  161.         {
  162.             if (alias_data[key] != match_filter[key])
  163.             {
  164.                 valid = false;
  165.                 break;
  166.             }
  167.         }
  168.        
  169.         if (valid)
  170.         {
  171.             aliases_data_filtered[name] = alias_data;
  172.         }
  173.     }
  174.    
  175.     return aliases_data_filtered;
  176. }
  177.  
  178. function Module_GetAliasNames(filter_module_names)
  179. {
  180.     var aliases_name_filtered = [];
  181.     var aliases_data = Storage_GetParameters("alias");
  182.    
  183.     for (var name in aliases_data)
  184.     {
  185.         var alias_data = eval("(" + aliases_data[name] + ")");
  186.        
  187.         if (!filter_module_names || in_array(filter_module_names, alias_data["module_name"]))
  188.         {
  189.             aliases_name_filtered.push(name)
  190.         }
  191.     }
  192.    
  193.     return aliases_name_filtered;
  194. }
  195.  
  196. function Module_GetAvailableIds(filter_module_names)
  197. {
  198.     var result_list = [];
  199.     var available_modules = ModuleExport_GetAvailableModules();
  200.    
  201.     for (var n in available_modules)
  202.     {
  203.         var id_parts = available_modules[n].split(":", 2);
  204.        
  205.         if (in_array(filter_module_names, id_parts[0]))
  206.         {
  207.             result_list.push(id_parts[1]);
  208.         }
  209.     }
  210.    
  211.     return result_list;
  212. }
  213.  
  214. function Module_GetNames()
  215. {
  216.     return [ "Dimmer230", "irTransmit" ];
  217. }
  218.  
  219. function Module_SendMessage(module_name, module_id, command, variables)
  220. {
  221.     var args = [];
  222.    
  223.     args.push(module_name + ":" + module_id);
  224.     args.push(command);
  225.    
  226.     var length = 0;
  227.     for (var key in variables)
  228.     {
  229.         length++;
  230.     }
  231.    
  232.     args.push(length);
  233.    
  234.     for (var key in variables)
  235.     {
  236.         args.push(key);
  237.         args.push(variables[key]);
  238.     }
  239.    
  240.     return ModuleExport_SendMessage.apply(null, Array.prototype.slice.call(args, 0));
  241. }
  242.  
  243. var Module_OnChangeFunctions = {};
  244. var Module_OnMessageFunctions = {};
  245.  
  246. function Module_RegisterToOnChange(alias_name, callback)
  247. {
  248.     if (!Module_OnChangeFunctions[alias_name])
  249.     {
  250.         Module_OnChangeFunctions[alias_name] = [];
  251.     }
  252.    
  253.     Module_OnChangeFunctions[alias_name].push(callback);
  254. }
  255.  
  256. function Module_RegisterToOnMessage(alias_name, callback)
  257. {
  258.     if (!Module_OnMessageFunctions[alias_name])
  259.     {
  260.         Module_OnMessageFunctions[alias_name] = [];
  261.     }
  262.    
  263.     Module_OnMessageFunctions[alias_name].push(callback);
  264. }
  265.  
  266. function Module_OnMessage(full_id, command, variables)
  267. {
  268.     var id_parts = full_id.split(":", 2);
  269.     var aliases_data = {};
  270.  
  271.     var aliases_data = Module_LookupAliases({
  272.         "module_name" : id_parts[0],
  273.         "module_id"   : id_parts[1],
  274.         "group"       : false
  275.     });
  276.    
  277.     for (var alias_name in aliases_data)
  278.     {
  279.         var ok = true;
  280.  
  281.         if (aliases_data[alias_name]["specific"])
  282.         {
  283.             var ok = true;
  284.            
  285.             for (var name in variables)
  286.             {
  287.                 if (aliases_data[alias_name]["specific"][name] && aliases_data[alias_name]["specific"][name] != variables[name])
  288.                 {
  289.                     ok = false;
  290.                     break;
  291.                 }
  292.             }
  293.         }
  294.        
  295.         if (Module_OnMessageFunctions[alias_name] && ok)
  296.         {
  297.             for (var n in Module_OnMessageFunctions[alias_name])
  298.             {
  299.                 Module_OnMessageFunctions[alias_name][n](alias_name, command, variables);
  300.             }
  301.         }
  302.     }
  303. }
  304.  
  305. function Module_OnChange(full_id, available)
  306. {
  307.     var id_parts = full_id.split(":", 2);
  308.     var aliases_data = {};
  309.    
  310.     var aliases_data_all = Module_LookupAliases({
  311.         "module_name" : id_parts[0],
  312.         "module_id"   : id_parts[1],
  313.         "group"       : false
  314.     });
  315.    
  316.     for (var alias_name in aliases_data)
  317.     {
  318.         var ok = true;
  319.        
  320.         if (aliases_data[alias_name]["specific"])
  321.         {
  322.             var ok = true;
  323.            
  324.             for (var name in variables)
  325.             {
  326.                 if (aliases_data[alias_name]["specific"][name] && aliases_data[alias_name]["specific"][name] != variables[name])
  327.                 {
  328.                     ok = false;
  329.                     break;
  330.                 }
  331.             }
  332.         }
  333.        
  334.         if (Module_OnChangeFunctions[alias_name] && ok)
  335.         {
  336.             for (var n in Module_OnChangeFunctions[alias_name])
  337.             {
  338.                 Module_OnChangeFunctions[alias_name][n](alias_name, available);
  339.             }
  340.         }
  341.     }
  342. }
  343.