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


 
Require("plugin/storage.js");
 
function Module_CreateAliasGroupAutoComplete(args)
{
    // args[0] == command name
    var arg_index = args.length - 2;
   
    if (arg_index == 0)
    {
        return Module_GetAliasNames();
    }
    else if (arg_index == 1)
    {
        return [ "Dimmer230", "irTransmit" ];
    }
    else if (arg_index >= 2)
    {
        return Module_GetAliasNames([ args[2] ])
    }
   
    return [];
}
 
function Module_CreateAliasGroup(alias_group_name, module_type, alias_name1, alias_name2)
{
    if (arguments.length < 3)
    {
        throw("Not enought parameters given");
    }
   
    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)
    {
        throw("No valid aliases were found, aborting creation of group alias");
    }
   
    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 (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_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_MessageAliasLookupFunctions = {};
var Module_OnChangeFunctions = {};
var Module_OnMessageFunctions = {};
 
function Module_RegisterMessageAliasLookup(module_name, callback)
{
    Module_MessageAliasLookupFunctions[module_name] = callback;
}
 
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 = {};
   
    if (Module_MessageAliasLookupFunctions[id_parts[0]])
    {
        aliases_data = Module_MessageAliasLookupFunctions[id_parts[0]](id_parts[1], command, variables);
    }
   
    for (var alias_name in alias_data)
    {
        if (Module_OnMessageFunctions[alias_name])
        {
            for (var n in Module_OnMessageFunctions[alias_name])
            {
                Module_OnMessageFunctions[alias_name][n](alias_name, command, variables);
            }
        }
    }
}
 
function Module_OnChange(full_id, available)
{
    var id_parts = full_id.split(":", 2);
   
    var aliases_data = Module_LookupAliases({
        "module_name" : id_parts[0],
        "module_id"   : id_parts[1],
    });
   
    for (var alias_name in alias_data)
    {
        if (Module_OnChangeFunctions[alias_name])
        {
            for (var n in Module_OnChangeFunctions[alias_name])
            {
                Module_OnChangeFunctions[alias_name][n](alias_name, available);
            }
        }
    }
}
 

Subversion Repositories HomeAutomation

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

Rev 1644		Rev 1646
1		1
2	Require("plugin/storage.js");	2	Require("plugin/storage.js");
3		3
4	function Module_CreateAliasGroupAutoComplete(args)	4	function Module_CreateAliasGroupAutoComplete(args)
5	{	5	{
6	// args[0] == command name	6	// args[0] == command name
7	var arg_index = args.length - 2;	7	var arg_index = args.length - 2;
8		8
9	if (arg_index == 0)	9	if (arg_index == 0)
10	{	10	{
11	return Module_GetAliasNames();	11	return Module_GetAliasNames();
12	}	12	}
13	else if (arg_index == 1)	13	else if (arg_index == 1)
14	{	14	{
15	return [ "Dimmer230", "irTransmit" ];	15	return [ "Dimmer230", "irTransmit" ];
16	}	16	}
17	else if (arg_index >= 2)	17	else if (arg_index >= 2)
18	{	18	{
19	return Module_GetAliasNames([ args[2] ])	19	return Module_GetAliasNames([ args[2] ])
20	}	20	}
21		21
22	return [];	22	return [];
23	}	23	}
24		24
25	function Module_CreateAliasGroup(alias_group_name, module_type, alias_name1, alias_name2)	25	function Module_CreateAliasGroup(alias_group_name, module_type, alias_name1, alias_name2)
26	{	26	{
27	if (arguments.length < 3)	27	if (arguments.length < 3)
28	{	28	{
29	throw("Not enought parameters given");	29	throw("Not enought parameters given");
30	}	30	}
31		31
32	alias_group_name = arguments[0];	32	alias_group_name = arguments[0];
33	module_type = arguments[1];	33	module_type = arguments[1];
34	var aliases = [];	34	var aliases = [];
35		35
36	for (var n = 2; n < arguments.length; n++)	36	for (var n = 2; n < arguments.length; n++)
37	{	37	{
38	if (arguments[n].length > 0)	38	if (arguments[n].length > 0)
39	{	39	{
40	var aliases_data = Module_ResolveAlias(arguments[n]);	40	var aliases_data = Module_ResolveAlias(arguments[n]);
41	aliases.push(arguments[n]);	41	aliases.push(arguments[n]);
42	}	42	}
43	}	43	}
44		44
45	if (aliases.length == 0)	45	if (aliases.length == 0)
46	{	46	{
47	throw("No valid aliases were found, aborting creation of group alias");	47	throw("No valid aliases were found, aborting creation of group alias");
48	}	48	}
49		49
50	var alias_data = {	50	var alias_data = {
51	"group" : true,	51	"group" : true,
52	"name" : alias_group_name,	52	"name" : alias_group_name,
53	"module_name" : module_type,	53	"module_name" : module_type,
54	"aliases" : aliases	54	"aliases" : aliases
55	};	55	};
56		56
57	return Storage_SetParameter("alias", alias_group_name, JSON.stringify(alias_data));	57	return Storage_SetParameter("alias", alias_group_name, JSON.stringify(alias_data));
58	}	58	}
59	Console_RegisterCommand(Module_CreateAliasGroup, Module_CreateAliasGroupAutoComplete);	59	Console_RegisterCommand(Module_CreateAliasGroup, Module_CreateAliasGroupAutoComplete);
60		60
61	function Module_ResolveAlias(alias_name, filter_module_names)	61	function Module_ResolveAlias(alias_name, filter_module_names)
62	{	62	{
63	var aliases_data = {};	63	var aliases_data = {};
64	var alias_data_string = Storage_GetParameter("alias", alias_name);	64	var alias_data_string = Storage_GetParameter("alias", alias_name);
65		65
66	if (alias_data_string)	66	if (alias_data_string)
67	{	67	{
68	var alias_data = eval("(" + alias_data_string + ")");	68	var alias_data = eval("(" + alias_data_string + ")");
69		69
70	if (alias_data["group"])	70	if (alias_data["group"])
71	{	71	{
72	for (var n in alias_data["aliases"])	72	for (var n in alias_data["aliases"])
73	{	73	{
74	var aliases_data_sub = Module_ResolveAlias(alias_data["aliases"][n]);	74	var aliases_data_sub = Module_ResolveAlias(alias_data["aliases"][n], filter_module_names);
75		75
76	for (var name in aliases_data_sub)	76	for (var name in aliases_data_sub)
77	{	77	{
78	aliases_data[name] = aliases_data_sub[name];	78	aliases_data[name] = aliases_data_sub[name];
79	}	79	}
80	}	80	}
81	}	81	}
82	else	82	else
83	{	83	{
84	if (in_array(filter_module_names, alias_data["module_name"]))	84	if (in_array(filter_module_names, alias_data["module_name"]))
85	{	85	{
86	aliases_data[alias_name] = alias_data;	86	aliases_data[alias_name] = alias_data;
87	}	87	}
88	}	88	}
89	}	89	}
90		90
91	return aliases_data;	91	return aliases_data;
92	}	92	}
93		93
94	function Module_LookupAliases(match_filter)	94	function Module_LookupAliases(match_filter)
95	{	95	{
96	var aliases_data_filtered = {};	96	var aliases_data_filtered = {};
97	var aliases_data = Storage_GetParameters("alias");	97	var aliases_data = Storage_GetParameters("alias");
98		98
99	for (var name in aliases_data)	99	for (var name in aliases_data)
100	{	100	{
101	var alias_data = eval("(" + aliases_data[name] + ")");	101	var alias_data = eval("(" + aliases_data[name] + ")");
102		102
103	var valid = true;	103	var valid = true;
104		104
105	for (var key in match_filter)	105	for (var key in match_filter)
106	{	106	{
107	if (alias_data[key] != match_filter[key])	107	if (alias_data[key] != match_filter[key])
108	{	108	{
109	valid = false;	109	valid = false;
110	break;	110	break;
111	}	111	}
112	}	112	}
113		113
114	if (valid)	114	if (valid)
115	{	115	{
116	aliases_data_filtered[name] = alias_data;	116	aliases_data_filtered[name] = alias_data;
117	}	117	}
118	}	118	}
119		119
120	return aliases_data_filtered;	120	return aliases_data_filtered;
121	}	121	}
122		122
123	function Module_GetAliasNames(filter_module_names)	123	function Module_GetAliasNames(filter_module_names)
124	{	124	{
125	var aliases_name_filtered = [];	125	var aliases_name_filtered = [];
126	var aliases_data = Storage_GetParameters("alias");	126	var aliases_data = Storage_GetParameters("alias");
127		127
128	for (var name in aliases_data)	128	for (var name in aliases_data)
129	{	129	{
130	var alias_data = eval("(" + aliases_data[name] + ")");	130	var alias_data = eval("(" + aliases_data[name] + ")");
131		131
132	if (!filter_module_names \|\| in_array(filter_module_names, alias_data["module_name"]))	132	if (!filter_module_names \|\| in_array(filter_module_names, alias_data["module_name"]))
133	{	133	{
134	aliases_name_filtered.push(name)	134	aliases_name_filtered.push(name)
135	}	135	}
136	}	136	}
137		137
138	return aliases_name_filtered;	138	return aliases_name_filtered;
139	}	139	}
140		140
141	function Module_GetAvailableIds(filter_module_names)	141	function Module_GetAvailableIds(filter_module_names)
142	{	142	{
143	var result_list = [];	143	var result_list = [];
144	var available_modules = ModuleExport_GetAvailableModules();	144	var available_modules = ModuleExport_GetAvailableModules();
145		145
146	for (var n in available_modules)	146	for (var n in available_modules)
147	{	147	{
148	var id_parts = available_modules[n].split(":", 2);	148	var id_parts = available_modules[n].split(":", 2);
149		149
150	if (in_array(filter_module_names, id_parts[0]))	150	if (in_array(filter_module_names, id_parts[0]))
151	{	151	{
152	result_list.push(id_parts[1]);	152	result_list.push(id_parts[1]);
153	}	153	}
154	}	154	}
155		155
156	return result_list;	156	return result_list;
157	}	157	}
158		158
159	function Module_SendMessage(module_name, module_id, command, variables)	159	function Module_SendMessage(module_name, module_id, command, variables)
160	{	160	{
161	var args = [];	161	var args = [];
162		162
163	args.push(module_name + ":" + module_id);	163	args.push(module_name + ":" + module_id);
164	args.push(command);	164	args.push(command);
165		165
166	var length = 0;	166	var length = 0;
167	for (var key in variables)	167	for (var key in variables)
168	{	168	{
169	length++;	169	length++;
170	}	170	}
171		-
172	Log("length=" + length);	-
173		171
174	args.push(length);	172	args.push(length);
175		173
176	for (var key in variables)	174	for (var key in variables)
177	{	175	{
178	args.push(key);	176	args.push(key);
179	args.push(variables[key]);	177	args.push(variables[key]);
180	}	178	}
181		179
182	return ModuleExport_SendMessage.apply(null, Array.prototype.slice.call(args, 0));	180	return ModuleExport_SendMessage.apply(null, Array.prototype.slice.call(args, 0));
183	}	181	}
184		182
185	var Module_MessageAliasLookupFunctions = {};	183	var Module_MessageAliasLookupFunctions = {};
186	var Module_OnChangeFunctions = {};	184	var Module_OnChangeFunctions = {};
187	var Module_OnMessageFunctions = {};	185	var Module_OnMessageFunctions = {};
188		186
189	function Module_RegisterMessageAliasLookup(module_name, callback)	187	function Module_RegisterMessageAliasLookup(module_name, callback)
190	{	188	{
191	Module_MessageAliasLookupFunctions[module_name] = callback;	189	Module_MessageAliasLookupFunctions[module_name] = callback;
192	}	190	}
193		191
194	function Module_RegisterToOnChange(alias_name, callback)	192	function Module_RegisterToOnChange(alias_name, callback)
195	{	193	{
196	if (!Module_OnChangeFunctions[alias_name])	194	if (!Module_OnChangeFunctions[alias_name])
197	{	195	{
198	Module_OnChangeFunctions[alias_name] = [];	196	Module_OnChangeFunctions[alias_name] = [];
199	}	197	}
200		198
201	Module_OnChangeFunctions[alias_name].push(callback);	199	Module_OnChangeFunctions[alias_name].push(callback);
202	}	200	}
203		201
204	function Module_RegisterToOnMessage(alias_name, callback)	202	function Module_RegisterToOnMessage(alias_name, callback)
205	{	203	{
206	if (!Module_OnMessageFunctions[alias_name])	204	if (!Module_OnMessageFunctions[alias_name])
207	{	205	{
208	Module_OnMessageFunctions[alias_name] = [];	206	Module_OnMessageFunctions[alias_name] = [];
209	}	207	}
210		208
211	Module_OnMessageFunctions[alias_name].push(callback);	209	Module_OnMessageFunctions[alias_name].push(callback);
212	}	210	}
213		211
214	function Module_OnMessage(full_id, command, variables)	212	function Module_OnMessage(full_id, command, variables)
215	{	213	{
216	var id_parts = full_id.split(":", 2);	214	var id_parts = full_id.split(":", 2);
217	var aliases_data = {};	215	var aliases_data = {};
218		216
219	if (Module_MessageAliasLookupFunctions[id_parts[0]])	217	if (Module_MessageAliasLookupFunctions[id_parts[0]])
220	{	218	{
221	aliases_data = Module_MessageAliasLookupFunctions[id_parts[0]](id_parts[1], command, variables);	219	aliases_data = Module_MessageAliasLookupFunctions[id_parts[0]](id_parts[1], command, variables);
222	}	220	}
223		221
224	for (var alias_name in alias_data)	222	for (var alias_name in alias_data)
225	{	223	{
226	if (Module_OnMessageFunctions[alias_name])	224	if (Module_OnMessageFunctions[alias_name])
227	{	225	{
228	for (var n in Module_OnMessageFunctions[alias_name])	226	for (var n in Module_OnMessageFunctions[alias_name])
229	{	227	{
230	Module_OnMessageFunctions[alias_name][n](alias_name, command, variables);	228	Module_OnMessageFunctions[alias_name][n](alias_name, command, variables);
231	}	229	}
232	}	230	}
233	}	231	}
234	}	232	}
235		233
236	function Module_OnChange(full_id, available)	234	function Module_OnChange(full_id, available)
237	{	235	{
238	var id_parts = full_id.split(":", 2);	236	var id_parts = full_id.split(":", 2);
239		237
240	var aliases_data = Module_LookupAliases({	238	var aliases_data = Module_LookupAliases({
241	"module_name" : id_parts[0],	239	"module_name" : id_parts[0],
242	"module_id" : id_parts[1],	240	"module_id" : id_parts[1],
243	});	241	});
244		242
245	for (var alias_name in alias_data)	243	for (var alias_name in alias_data)
246	{	244	{
247	if (Module_OnChangeFunctions[alias_name])	245	if (Module_OnChangeFunctions[alias_name])
248	{	246	{
249	for (var n in Module_OnChangeFunctions[alias_name])	247	for (var n in Module_OnChangeFunctions[alias_name])
250	{	248	{
251	Module_OnChangeFunctions[alias_name][n](alias_name, available);	249	Module_OnChangeFunctions[alias_name][n](alias_name, available);
252	}	250	}
253	}	251	}
254	}	252	}
255	}	253	}
256		254