source: sandbox/2.2.0.2/expressoAdmin1_2/js/jscode/finder.js @ 4445

Revision 4445, 8.1 KB checked in by airton, 13 years ago (diff)

Ticket #1908 - Implementacao de melhorias na conta compartilhada - Adicao de arquivos e bibliotecas necessarias

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