source: trunk/expressoAdmin1_2/js/jscode/finder.js @ 5407

Revision 5407, 8.1 KB checked in by alexandrecorreia, 12 years ago (diff)

Ticket #2454 - Busca no ldap sem a necessidade de parametros.

  • Property svn:executable set to *
Line 
1
2var current_value = "";
3
4var default_limit = 0;
5
6var sizelimit = 10;
7
8function Element( id )
9{
10    return document.getElementById( id );
11}
12
13function optionFind( id, selectId, url, ctxId, labelId )
14{
15    var fillHandler = function( fill, raw ){
16
17        return fillContentSelect( fill, selectId );
18
19    };
20
21    getAvailable( id, fillHandler, url, ctxId, labelId, true );
22}
23
24function getAvailable( id, fillHandler, url, ctxId, labelId, bypass )
25{
26    if( id )
27    {
28        var sentence = Element( id );
29
30        sentence = sentence ? sentence.value : id;
31       
32        url += "&filter=" + sentence + "&sentence=" + sentence;
33    }
34
35    if( ctxId )
36    {
37        var ctx = Element( ctxId );
38       
39        ctx = ctx ? ctx.value : ctxId;
40
41        url += "&context=" + ctx;
42    }
43
44    if( bypass )
45        bypass = bypassParser;
46
47    userFinder( sentence, fillHandler, url, bypass, labelId );
48}
49
50var default_field = "cn";
51
52function userFinder( sentence, selectId, url, handler, labelId )
53{
54    //current_value = sentence;
55    if( typeof limit === "undefined" )
56        limit = default_limit;
57
58    //TODO: tornar esse limite configuravel de acordo com a configuracao do expresso
59    if( sentence.length < limit )
60        return( false );
61
62    if( typeof handler === "string" &&
63        typeof labelId === "undefined" )
64        labelId = handler,
65        handler = undefined;
66
67    if( typeof get_lang === "undefined" )
68        get_lang = function( key ){
69            var translator = Element( "txt_" + key );
70
71            return translator ? translator.value : key;
72        };
73
74    var urlHandler = function(){
75
76            if( labelId )
77                Element( labelId ).innerHTML = get_lang('searching') + '...';
78
79            if( typeof url === "function" )
80                url = url();
81
82            return( url );
83    };
84
85    var defaultParser = function( data, raw ){
86
87        if( labelId )
88            Element( labelId ).innerHTML = '&nbsp;';
89
90            var result = false;
91
92            if( handler )
93                result = handler( data, raw );
94
95            if( result )
96                return( result );
97
98        if( typeof data === "string" )
99            return( data );
100
101        return stackParser( data, default_field );
102    };
103
104    var fillHandler = function( fill, raw )
105    {
106        var sizeof = 0;
107
108        if( typeof selectId === "string" )
109            sizeof = fillSelect( fill, selectId, default_field );
110        else
111            sizeof = selectId( fill, raw );
112
113        if( labelId && sizeof >= sizelimit )
114            Element( labelId ).innerHTML = 'Muitos resultados encontrados. Por favor, refine sua busca.';
115
116        return( !sizeof );
117    }
118
119    return finder( sentence, fillHandler, urlHandler, defaultParser );
120}
121
122function finder( sentences, fillHandler, url, parser )
123{
124    //caso fillHandler nao seja uma funcao, usar a default
125//     if( typeof fillHandler === "string" )
126//     {
127//      var selectId = fillHandler;
128//
129//      fillHandler = function( fill ){
130//
131//          return !fillSelect( fill, selectId, default_field );
132//
133//      };
134//     }
135
136    return lookup( sentences, fillHandler, url, parser, fillHandler );
137}
138
139function getExp( sentence )
140{
141   sentence = sentence.replace(/^\s*/, "").replace(/\s*$/, "");
142 
143   sentence = sentence.replace( / /gi, ".*" );
144
145   sentence = new RegExp( ".*" + sentence + ".*", "i" );
146
147    return( sentence );
148}
149
150var options_cache = {};
151
152function setOptions( fill, select, field )
153{
154    for( var value in fill )
155    {
156        if( !options_cache[value] )
157             options_cache[value] = {};
158
159        if( !options_cache[value][field] )
160             options_cache[value][field] = new Option( fill[value][field], value );
161
162        select[select.length] = options_cache[value][field];
163    }
164
165    return( select );
166}
167
168function fillSelect( fill, selectId, field )
169{
170    //recupera as options do respectivo select
171    var select = Element( selectId ).options;
172
173    //Limpa todo o select
174    select.length = 0;
175
176    //Inclui usuario comecando com a pesquisa
177    select = setOptions( fill, select, field );
178
179    //chama o server side caso nao encontre resultado nenhum com essa sentenca
180    return( select.length );
181}
182
183function fillContentSelect( fill, selectId )
184{
185    if( typeof fill === "string" )
186    {
187        var select = Element( selectId );
188
189        select.innerHTML = fill;
190
191        return( select.options.length );
192    }
193
194    var content = "";
195
196    for( var section in fill )
197    {
198        if( !fill[section] || fill[section] === "" )
199            continue;
200
201        var entry = entryTag( section );
202
203        content += entry.outerHTML;
204        content += fill[section];
205    }
206
207    return fillContentSelect( content, selectId );
208}
209
210
211function entryTag( label, select )
212{
213    var line = '-------------------';
214
215    var option = new Option( line + ' ' + get_lang(label) + ' ' + line + ' ', -1 );
216    option.disabled = true;
217
218    if( typeof select === "undefined" )
219        return( option );
220
221    if( typeof select === "string" )
222        select = Element( select ).options;
223
224    if( select.options )
225        select = select.options;
226
227    select[select.length] = option;
228}
229
230function fillGroupableSelect( fill, selectId, groupHandler, field )
231{
232    var groups = {};
233
234    var select = Element( selectId ).options;
235
236    var sizeof = select.length = 0;
237
238    for( value in fill )
239    {
240        var target = fill[value];
241
242        var group = groupHandler( target );
243
244        if( !groups[ group ] )
245            groups[ group ] = {};
246
247        groups[ group ][ value ] = target;
248
249        sizeof++;
250    }
251
252    for( groupId in groups )
253    {
254        var group = groups[ groupId ];
255
256         entryTag( groupId, select );
257
258        select = setOptions( group, select, field );
259    }
260
261    return( sizeof );
262}
263
264function flipParser( data )
265{
266    var result = {};
267
268    for( var section in data )
269    {
270        var target = data[section];
271
272        for ( var key in target )
273        {
274            if( !result[key] )
275                result[key] = {};
276
277            result[key][section] = target[key];
278        }
279    }
280
281    return( result );
282}
283
284function stackParser( data, field )
285{
286    if( !data ) return( false );
287
288    for( var section in data )
289        data[section] = normalize( data[section], field );
290
291    return( data );
292}
293
294function bypassParser( x ){
295    return( x );
296}
297
298var userData = {};
299
300function lookup( matchers, fillHandler, url, parser, callback )
301{
302    var serverCallback = false;
303
304    if( url )
305    {
306        //handler chamado pelo callback do servidor para repopular.
307        serverCallback = function( filters, handler ){
308
309            var refill = function( userd, data ){
310
311                //no caso de existir um custom callback
312                if( callback )
313                    if( !callback( data, userd ) )
314                        return;
315
316                //filter( filters, handler );
317
318            };
319
320            search( url, refill, parser );
321        };
322    }
323
324    serverCallback( matchers, fillHandler, serverCallback );
325}
326
327function filter( filters, fillHandler, emptinessHandler )
328{
329    filters = normalize( filters );
330
331    var fill = {};
332
333    //varrer todas as sentencas e secoes especificas
334    for( key in userData )
335    {
336        var user = userData[key];
337
338        if( !user ) continue;
339
340        var filtered = false;
341
342        //populando o mapa filtrando pela determinada sentenca
343        for( section in filters )
344        {
345            if( filtered ) break;
346
347            //filtro para a secao especifica.
348            var criteria = filters[section];
349
350            var target = user[section] || user;
351
352            if( !criteria( target ) )
353                filtered = true;
354        }
355
356        if( !filtered )
357            fill[key] = user;
358    }
359
360    //tenta chamar o handler para popular, caso nao consiga chama o server side
361    if( fillHandler )
362        if( !fillHandler( fill ) && emptinessHandler )
363            return emptinessHandler( filters, fillHandler );
364
365    return( fill );
366}
367
368function search( url, callback, parser )
369{
370    var handler = function( data )
371    {
372        if( !cExecute )
373            data = unserialize( data );
374
375        var dt = false;
376
377        if( typeof data == "string" && data.charAt(0) === '{' )
378        {
379            try{
380                dt = data;
381                data = (new Function("return " + data))();
382            }
383            catch(e){
384            }
385        }
386
387//      if( data && typeof data !== "string" && data.nosession )
388//          window.location.reload( false );
389
390        if( parser )
391            data = parser( data, dt );
392
393        if( callback )
394            callback( userData, data );
395    }
396
397    if( typeof url === "function" )
398        url = url();
399
400    if( typeof cExecute !== "undefined" )
401        return cExecute( url, handler );
402
403    return this.Connector.newRequest( 'search', url, 'GET', handler );
404}
405
406function normalize( raw, field )
407{
408    if( raw instanceof RegExp )
409    {
410        var exp = raw;
411
412        raw = function( match ){
413            return exp.test( match );
414        }
415    }
416
417    if( typeof field !== "undefined" && raw !== "object" )
418    {
419        var content = raw;
420
421        raw = {};
422       
423        raw[field] = content;
424    }
425
426    if( typeof raw === "object" )
427        for( var key in raw )
428            raw[key] = normalize( raw[key] );
429
430    return( raw );
431}
Note: See TracBrowser for help on using the repository browser.