WebSVN – HomeAutomation – Diff – /trunk/PcSoftware/Atom1.5/script/plugin/module.js


 
Require("plugin/storage.js");
 
function Module_CreateAliasAutoComplete(arg_index, args)
{
    if (arg_index == 0)
    {
        return Module_GetAliasNames();
    }
    else if (arg_index == 1)
    {
        return Module_GetNames();
    }
    else if (arg_index == 2)
    {
        return Module_GetAvailableIds([ args[1] ])
    }
   
    return [];
}
 
function Module_CreateAlias(alias_name, module_name, module_id, specific)
{
    if (arguments.length < 3)
    {
        Log("\033[31mNot enough parameters given.\033[0m\n");
        return false;
    }
   
    if (alias_name == "all")
    {
        Log("\033[31m\"all\" is not allowed as alias name.\033[0m\n");
        return false;
    }
   
    var specific_list = {};
   
    if (specific)
    {
        var specific_parts = specific.split(",");
       
        // TODO: Check length
       
        for (var index in specific_parts)
        {
            var parts = specific_parts[index].split("=");
           
            // TODO: Check length
           
            specific_list[parts[0]] = parts[1];
        }
    }
   
    var alias_data = {
        "group"       : false,
        "name"        : alias_name,
        "module_name" : module_name,
        "module_id"   : module_id,
        "specific"    : specific_list
    };
   
    return Storage_SetParameter("alias", alias_name, JSON.stringify(alias_data));
}
Console_RegisterCommand(Module_CreateAlias, Module_CreateAliasAutoComplete);
 
function Module_CreateAliasGroupAutoComplete(arg_index, args)
{
    if (arg_index == 0)
    {
        return Module_GetAliasNames();
    }
    else if (arg_index == 1)
    {
        return Module_GetNames();
    }
    else if (arg_index >= 2)
    {
        return Module_GetAliasNames([ args[1] ])
    }
   
    return [];
}
 
function Module_CreateAliasGroup(alias_group_name, module_type, alias_name1, alias_name2)
{
    if (arguments.length < 3)
    {
        Log("\033[31mNot enough parameters given.\033[0m\n");
        return false;
    }
   
    if (alias_group_name == "all")
    {
        Log("\033[31m\"all\" is not allowed as alias name.\033[0m\n");
        return false;
    }
   
    alias_group_name = arguments[0];
    module_type = arguments[1];
    var aliases = [];
   
    for (var n = 2; n < arguments.length; n++)
    {
        if (arguments[n].length > 0)
        {
            var aliases_data = Module_ResolveAlias(arguments[n]);
            aliases.push(arguments[n]);
        }
    }
   
    if (aliases.length == 0)
    {
        Log("\033[31mNo valid aliases were found, aborting creation of group alias.\033[0m\n");
        return false;
    }
   
    var alias_data = {
        "group"       : true,
        "name"        : alias_group_name,
        "module_name" : module_type,
        "aliases"     : aliases
    };
   
    return Storage_SetParameter("alias", alias_group_name, JSON.stringify(alias_data));
}
Console_RegisterCommand(Module_CreateAliasGroup, Module_CreateAliasGroupAutoComplete);
 
function Module_ResolveAlias(alias_name, filter_module_names)
{
    var aliases_data = {};
    var alias_data_string = Storage_GetParameter("alias", alias_name);
   
    if (alias_data_string)
    {
        var alias_data = eval("(" + alias_data_string + ")");
       
        if (alias_data["group"])
        {
            for (var n in alias_data["aliases"])
            {
                var aliases_data_sub = Module_ResolveAlias(alias_data["aliases"][n], filter_module_names);
               
                for (var name in aliases_data_sub)
                {
                    aliases_data[name] = aliases_data_sub[name];
                }
            }
        }
        else
        {
            if (!filter_module_names || in_array(filter_module_names, alias_data["module_name"]))
            {
                aliases_data[alias_name] = alias_data;
            }
        }
    }
   
    return aliases_data;
}
 
function Module_LookupAliases(match_filter)
{
    var aliases_data_filtered = {};
    var aliases_data = Storage_GetParameters("alias");
   
    for (var name in aliases_data)
    {
        var alias_data = eval("(" + aliases_data[name] + ")");
       
        var valid = true;
       
        for (var key in match_filter)
        {
            if (alias_data[key] != match_filter[key])
            {
                valid = false;
                break;
            }
        }
       
        if (valid)
        {
            aliases_data_filtered[name] = alias_data;
        }
    }
   
    return aliases_data_filtered;
}
 
function Module_GetAliasNames(filter_module_names)
{
    var aliases_name_filtered = [];
    var aliases_data = Storage_GetParameters("alias");
   
    for (var name in aliases_data)
    {
        var alias_data = eval("(" + aliases_data[name] + ")");
       
        if (!filter_module_names || in_array(filter_module_names, alias_data["module_name"]))
        {
            aliases_name_filtered.push(name)
        }
    }
   
    return aliases_name_filtered;
}
 
function Module_GetAvailableIds(filter_module_names)
{
    var result_list = [];
    var available_modules = ModuleExport_GetAvailableModules();
   
    for (var n in available_modules)
    {
        var id_parts = available_modules[n].split(":", 2);
       
        if (in_array(filter_module_names, id_parts[0]))
        {
            result_list.push(id_parts[1]);
        }
    }
   
    return result_list;
}
 
function Module_GetNames()
{
    return [ "Dimmer230", "irTransmit", "irReceive", "SimpleDTMF", "BusVoltage", "DS18x20", "FOST02", "HD44789", "Rotary", "RotaryHex", "Touch", "power", "input", "output", "softPWM", "counter", "rfTransceive", "hwPWM", "KS0108", "heatPower"];
}
 
function Module_SendMessage(module_name, module_id, command, variables)
{
    var args = [];
   
    args.push(module_name + ":" + module_id);
    args.push(command);
   
    var length = 0;
    for (var key in variables)
    {
        length++;
    }
   
    args.push(length);
   
    for (var key in variables)
    {
        args.push(key);
        args.push(variables[key]);
    }
   
    return ModuleExport_SendMessage.apply(null, Array.prototype.slice.call(args, 0));
}
 
var Module_OnChangeFunctions = {};
var Module_OnMessageFunctions = {};
 
function Module_RegisterToOnChange(alias_name, callback)
{
    if (!Module_OnChangeFunctions[alias_name])
    {
        Module_OnChangeFunctions[alias_name] = [];
    }
   
    Module_OnChangeFunctions[alias_name].push(callback);
}
 
function Module_RegisterToOnMessage(alias_name, callback)
{
    if (!Module_OnMessageFunctions[alias_name])
    {
        Module_OnMessageFunctions[alias_name] = [];
    }
   
    Module_OnMessageFunctions[alias_name].push(callback);
}
 
function Module_OnMessage(full_id, command, variables)
{
    var id_parts = full_id.split(":", 2);
    var aliases_data = {};
 
    var aliases_data = Module_LookupAliases({
        "module_name" : id_parts[0],
        "module_id"   : id_parts[1],
        "group"       : false
    });
   
    for (var alias_name in aliases_data)
    {
        var ok = true;
 
        if (aliases_data[alias_name]["specific"])
        {
            var ok = true;
           
            for (var name in variables)
            {
                if (aliases_data[alias_name]["specific"][name] && aliases_data[alias_name]["specific"][name] != variables[name])
                {
                    ok = false;
                    break;
                }
            }
        }
       
        if (Module_OnMessageFunctions[alias_name] && ok)
        {
            for (var n in Module_OnMessageFunctions[alias_name])
            {
                Module_OnMessageFunctions[alias_name][n](alias_name, command, variables);
            }
        }
    }
   
    if (Module_OnMessageFunctions["all"])
    {
        for (var n in Module_OnMessageFunctions["all"])
        {
            Module_OnMessageFunctions["all"][n](id_parts[0], id_parts[1], command, variables);
        }
    }
}
 
function Module_OnChange(full_id, available)
{
    var id_parts = full_id.split(":", 2);
    var aliases_data = {};
   
    aliases_data = Module_LookupAliases({
        "module_name" : id_parts[0],
        "module_id"   : id_parts[1],
        "group"       : false
    });
    for (var alias_name in aliases_data)
    {
        var ok = true;
       
        if (Module_OnChangeFunctions[alias_name])
        {
            for (var n in Module_OnChangeFunctions[alias_name])
            {
                Module_OnChangeFunctions[alias_name][n](alias_name, available);
            }
        }
    }
   
    if (Module_OnChangeFunctions["all"])
    {
        for (var n in Module_OnChangeFunctions["all"])
        {
            Module_OnChangeFunctions["all"][n](id_parts[0], id_parts[1], available);
        }
    }
}
 
function Module_GetLastValue(alias_name)
{
    if (arguments.length < 1)
    {
        Log("\033[31mNot enough parameters given.\033[0m\n");
        return false;
    }
   
    var aliases_data = Module_ResolveAlias(alias_name);
    var found = false;
   
    for (var name in aliases_data)
    {
        var last_value_string = Storage_GetParameter("LastValues", name);
       
        if (last_value_string)
        {
            Log("\033[0;1mStored values for " + name + ":\033[0m\n");
            var last_value = eval("(" + last_value_string + ")");
           
            for (var type_name in last_value)
            {
                var date = new Date(last_value[type_name]["timestamp"] * 1000);
               
                Log("\033[96m" + type_name + ": \033[0;1m" + last_value[type_name]["value"] + "\033[0m at " + date.toString() + "\n");
            }
        }
        else
        {
            Log("\033[32mNo value is stored for " + name + ".\033[0m\n");
        }
       
        found = true;
    }
   
    if (!found)
    {
        Log("\033[31mNo aliases by the name " + alias_name + " were applicable for this command.\033[0m\n");
        return false;
    }
   
    return true;
}
Console_RegisterCommand(Module_GetLastValue, function(arg_index, args) { return Console_StandardAutocomplete(arg_index, args, Module_GetAliasNames()); });
 
function Module_ListAvailable()
{
    var available_modules = ModuleExport_GetAvailableModules();
   
    var lines = [["Id", "Name", "Aliases"]];
   
    for (var n in available_modules)
    {
        var id_parts = available_modules[n].split(":", 2);
        var alias = "<none>";
       
        var alias_names = get_keys(Module_LookupAliases({
            "module_name" : id_parts[0],
            "module_id"   : id_parts[1],
            "group"       : false
        }));
       
        if (alias_names.length > 0)
        {
            alias = alias_names.join(", ");
        }
       
        lines.push([id_parts[1], id_parts[0], alias]);
    }
   
    var table_lines = create_table(lines);
   
    Log("\033[29;1m" + table_lines[0] + "\033[0m\n");
   
    for (var n = 1; n < table_lines.length; n++)
    {
        Log(table_lines[n] + "\n");
    }
   
    return true;
}
Console_RegisterCommand(Module_ListAvailable);
 
function Module_GetLastData(alias_name)
{
    if (arguments.length < 1)
    {
        Log("\033[31mNot enough parameters given.\033[0m\n");
        return false;
    }
   
    var aliases_data = Module_ResolveAlias(alias_name);
    var found = false;
   
    for (var name in aliases_data)
    {
        var last_value_string = Storage_GetParameter("LastValues", name);
       
        if (last_value_string)
        {
            Log("\033[0;1mStored values for " + name + ":\033[0m\n");
            var last_value = eval("(" + last_value_string + ")");          
            for (var type_name in last_value)
            {
                var date = new Date(last_value[type_name]["timestamp"] * 1000);
                var text = "";
                for (var data in last_value[type_name])
                {
                    if (data != "timestamp"){
                        text += data+"="+last_value[type_name][data]+" ";
                    }
                }
                Log("\033[96m" + type_name + ": \033[0;1m" + text + "\033[0m at " + date.toString() + "\n");
            }
        }
        else
        {
            Log("\033[32mNo value is stored for " + name + ".\033[0m\n");
        }
       
        found = true;
    }
   
    if (!found)
    {
        Log("\033[31mNo aliases by the name " + alias_name + " were applicable for this command.\033[0m\n");
        return false;
    }
   
    return true;
}
Console_RegisterCommand(Module_GetLastData, function(arg_index, args) { return Console_StandardAutocomplete(arg_index, args, Module_GetAliasNames()); });
 
function Module_GetLastDataRaw(alias_name)
{
    var result = { results : {} };
 
 
  for (var n = 0; n < arguments.length; n++)
    {
 
 
 
 
      var aliases_data = Module_ResolveAlias(arguments[n]);
 
 
 
   
      for (var name in aliases_data)
      {
          var last_value_string = Storage_GetParameter("LastValues", name);
       
          if (last_value_string)
          {
            result.results[name] = JSON.parse(last_value_string);
          }
          else
          {
            result.results[name] = {};
          }
    }
    }
   
    Log(JSON.stringify(result)+'\n');
    return true;
}
Console_RegisterCommand(Module_GetLastDataRaw, function(arg_index, args) { return Console_StandardAutocomplete(arg_index, args, Module_GetAliasNames()); });
 
 

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

Subversion Repositories HomeAutomation

(root)/trunk/PcSoftware/Atom1.5/script/plugin/module.js – Rev 2053 → 2067