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" ];
}
 
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 = {};
   
    var aliases_data_all = 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_OnChangeFunctions[alias_name] && ok)
        {
            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);
 

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

Subversion Repositories HomeAutomation

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