Project

General

Profile

Bug #1203 » MinovaXtype.js

Tri Rizqiaty, 07/20/2022 10:18 AM

 
1
var isMobile = {
2
    Android: function () {
3
        return navigator.userAgent.match(/Android/i);
4
    },
5
    BlackBerry: function () {
6
        return navigator.userAgent.match(/BlackBerry/i);
7
    },
8
    iOS: function () {
9
        return navigator.userAgent.match(/iPhone|iPad|iPod/i);
10
    },
11
    Opera: function () {
12
        return navigator.userAgent.match(/Opera Mini/i);
13
    },
14
    Windows: function () {
15
        return navigator.userAgent.match(/IEMobile/i) || navigator.userAgent.match(/WPDesktop/i);
16
    },
17
    any: function () {
18
        return (isMobile.Android() || isMobile.BlackBerry() || isMobile.iOS() || isMobile.Opera() || isMobile.Windows());
19
    }
20
};
21
var isDesk = true;
22
var layoutForm = 'column';
23
if (isMobile.Android() != null || isMobile.BlackBerry() != null || isMobile.iOS() != null) {
24
    isDesk = false;
25
    layoutForm = 'column'
26
} else {
27
    isDesk = true;
28
    layoutForm = 'column';
29
}
30

    
31
Ext.define('MinovaUtil.MinovaES.MinovaLookupGridold', {
32
    extend: 'Ext.form.field.Trigger',
33
    alias: ['widget.minovalookupgridold'],
34

    
35
    tableName: undefined,
36
    param: undefined,
37
    formtarget: undefined,
38
    anchor: '50%',
39
    pagesize: undefined,
40
    fieldTarget: undefined,
41
    fieldValue: undefined,
42
    isGrid: undefined,
43
    isMultiSelect: undefined,
44
    LookupFunction: undefined,
45
    SearchFunction: undefined,
46

    
47
    trigger1Cls: Ext.baseCSSPrefix + 'form-clear-trigger',
48
    trigger2Cls: Ext.baseCSSPrefix + 'form-search-trigger',
49
    setValue: function (v) {
50
        var me = this;
51
        var value = v;
52
        this.value = '';
53
        this.value = v;
54
        if (value != "" && value != undefined) {
55
            data_ = undefined;
56
            Ext.Ajax.request({
57
                async: false,
58
                method: 'POST',
59
                url: '/UserControl/GetStore',
60
                params: {
61
                    tableName: 'PDSCMTABLE',
62
                    param: this.tableName + ',' + v + ',hasil'
63
                },
64
                success: function (response) {
65
                    var results = Ext.decode(response.responseText);
66
                    data_ = results.data
67
                    if (data_.length > 0) {
68
                        me.setRawValue(v + ' - ' + data_[0].hasil)
69

    
70
                    }
71
                }
72
            });
73
        }
74
    },
75
    getValue: function () {
76
        var hasil = this.value;
77
        if (this.valData) {
78
            hasil = this.valData;
79
        }
80
        return hasil;
81
    },
82
    getSubmitValue: function () {
83
        var hasil = this.value;
84
        if (this.valData) {
85
            hasil = this.valData;
86
        }
87
        return hasil;
88
    },
89
    initComponent: function () {
90
        //var formtarget_ = this.formtarget;
91
        var pagesize = this.pagesize;
92
        var tableName = this.tableName;
93
        this.callParent();
94
    },
95
    onRender: function () {
96
        var me = this,
97
		el;
98

    
99
        me.callParent(arguments);
100

    
101
        el = me.triggerEl.first().parent();
102
        el.setVisibilityMode(Ext.Element.DISPLAY);
103
        el.hide();
104
    },
105

    
106
    onChange: function (newVal, oldVal) {
107
        var me = this
108
        el = me.triggerEl.first().parent();
109

    
110
        me.callParent(arguments);
111

    
112
        if (newVal.length) {
113
            el.show();
114
        } else {
115
            el.hide();
116
        }
117
    },
118

    
119
    onTrigger1Click: function (event) {
120
        var me = this;
121
        if (me.hideTrigger) {
122
            return;
123
        }
124
        me.setValue("");
125
        me.fireEvent('cleartriggerclick', me, event);
126
    },
127
    onTrigger2Click: function () {
128
        //alert('asa')
129
        var isGrid_ = this.isGrid;
130
        var fieldTarget_ = this.fieldTarget;
131
        var formtarget_ = this.formtarget;
132
        var fieldValue_ = this.fieldValue;
133
        var tableName = this.tableName;
134
        var LookupFunction_ = this.LookupFunction;
135
        var SearchFunction_ = this.SearchFunction;
136
        var pnl = Ext.ComponentQuery.query('[name=' + formtarget_ + ']')[0];
137

    
138
        if (tableName == 'PDSPY0006') {
139
            Ext.create('Ext.window.Window', {
140
                title: 'Lookup - ' + this.fieldLabel,
141
                //hamid
142
                controller: 'rdlreportPayResult',
143
                //end hamid
144
                height: 530,
145
                width: 500,
146
                fieldTarget: fieldTarget_,
147
                fieldValue: fieldValue_,
148
                isGrid: isGrid_,
149
                name: 'lookupMain',
150
                //modal: true,
151
                listeners: {
152
                    'beforeshow': function (g) {
153
                        pnl.mask('Loading...');
154
                        setTimeout(function () {
155
                            pnl.unmask();
156
                        }, 100);
157
                    }
158
                },
159
                items: [{
160
                    xtype: 'minovaform',
161
                    bodyBorder: false,
162
                    MaxHeigth: '100',
163
                    cls: 'borderLookup',
164
                    border: false,
165
                    scroll: true,
166
                    isLookup: true,
167
                    name: "formLookupFilter",
168
                    tableName: this.tableName,
169
                    buttons: [{
170
                        text: 'Search',
171
                        //iconCls : 'fa-edit',
172
                        //style : 'font-family: FontAwesome',
173
                        handler: function () {
174
                            var store = Ext.data.StoreManager.lookup('lookupStore');
175
                            var form = Ext.ComponentQuery.query('[name=formLookupFilter]')[0].getForm();
176
                            grid = Ext.ComponentQuery.query('[name=gridLookup]')[0];
177
                            var values_ = form.getValues();
178
                            var fields_ = form.getFields().items;
179
                            var param_ = '';
180
                            for (var i = 0; i < fields_.length; i++) {
181
                                var val_ = form.getFields().items[i].getValue();
182
                                var xtype_ = form.getFields().items[i].xtype;
183
                                var oprator_ = '[like]';
184
                                if (xtype_ == 'combobox' || xtype_ == 'combo' || xtype_ == 'minovacombo' || xtype_ == 'minovacombobox') {
185
                                    oprator_ = '[Equal]';
186
                                }
187
                                if (xtype_ == 'datefield') {
188
                                    if (form.getFields().items[i].name == 'StartDate' || form.getFields().items[i].name == 'ValidForm') {
189
                                        oprator_ = '[LessThanEqual]';
190
                                    } else {
191
                                        oprator_ = '[GreaterThanEqual]';
192
                                    }
193
                                }
194
                                if (val_ != 'undefined' && val_ != "" && val_ != null) {
195
                                    param_ = param_ + ',' + form.getFields().items[i].name + oprator_ + val_;
196
                                }
197
                            }
198
                            store.proxy.extraParams = {
199
                                tableName: grid.tableName,
200
                                param: param_,
201
                                menuId: MinovaUtil.GetMenuID()
202
                            };
203
                            store.removeAll();
204
                            store.reload();
205
                            store.loadPage(1);
206
                        }
207

    
208
                    }
209
                    ],
210
                }, {
211
                    xtype: 'minovagrid1',
212
                    isLookup: true,
213
                    autoLoad: false,
214
                    minHeight: 280,
215
                    height: 380,
216
                    tableName: this.tableName,
217
                    param: '',
218
                    //name: 'gridForm' + this.tableName,
219
                    name: 'gridLookup',
220
                    hidebutton: 0,
221
                    pagesize: 25,
222
                    storename: 'lookupStore',
223
                    listeners: {
224
                        itemdblclick: function (g) {
225

    
226
                            var me = this;
227
                            var selection = this.getView().getSelectionModel().getSelection()[0];
228
                            var name_ = 'form[name=' + formtarget_ + ']';
229
                            var form_ = Ext.ComponentQuery.query(name_)[0].getForm();
230
                            var mainLookup = Ext.ComponentQuery.query('[name=lookupMain]')[0];
231
                            var targetField = mainLookup.fieldTarget;
232
                            if (mainLookup.isGrid) {
233
                                if (targetField) {
234
                                    targetField = targetField.split('$')
235
                                    var dt = targetField[0].split(',');
236
                                    var fieldValue = targetField[1].split(',');
237
                                    if (fieldValue.length > 0) {
238
                                        for (i in dt) {
239
                                            field_ = dt[i];
240
                                            Ext.ComponentQuery.query('[id=' + 'grid' + field_ + ']')[0].setValue(eval('selection.data.' + fieldValue[i]))
241
                                        }
242
                                    } else {
243
                                        for (i in dt) {
244
                                            field_ = dt[i];
245
                                            Ext.ComponentQuery.query('[id=' + 'grid' + field_ + ']')[0].setValue(eval('selection.data.' + field_))
246
                                        }
247
                                    }
248

    
249
                                }
250
                            }
251
                            //else {// untuk form
252
                            if (targetField) {
253
                                var dt = targetField.split(',');
254
                                var fieldValue = mainLookup.fieldValue.split(',');
255
                                if (fieldValue.length > 0) {
256
                                    for (i in dt) {
257
                                        field_ = dt[i];
258
                                        Ext.ComponentQuery.query('[name=' + field_ + ']')[0].setValue(eval('selection.data.' + fieldValue[i]))
259
                                    }
260
                                } else {
261
                                    for (i in dt) {
262
                                        field_ = dt[i];
263
                                        Ext.ComponentQuery.query('[name=' + field_ + ']')[0].setValue(eval('selection.data.' + field_))
264
                                    }
265
                                }
266
                            } else {
267
                                form_.setValues(selection.data);
268
                            }
269
                            //}
270

    
271
                            mainLookup.destroy();
272
                        },
273
                        beforeedit: function (grid) {
274
                            return false;
275
                        }
276
                    },
277
                    dockedItems: [{
278
                        xtype: 'pagingtoolbar',
279
                        store: 'lookupStore',
280
                        dock: 'bottom',
281
                        pageSize: 25,
282
                        displayInfo: true
283
                    }
284
                    ]
285

    
286
                }, ]
287
            }).show();
288
        } else {
289
            // hamid
290
            Ext.create('Ext.window.Window', {
291
                title: 'Lookup - ' + this.fieldLabel,
292
                height: 560,
293
                width: 500,
294
                fieldTarget: fieldTarget_,
295
                fieldValue: fieldValue_,
296
                isGrid: isGrid_,
297
                name: 'lookupMain',
298
                //modal: true,
299
                listeners: {
300
                    'beforeshow': function (g) {
301
                        pnl.mask('Loading...');
302
                        setTimeout(function () {
303
                            pnl.unmask();
304
                        }, 100);
305
                    }
306
                },
307
                items: [{
308
                    xtype: 'minovaform',
309
                    bodyBorder: false,
310
                    MaxHeigth: '100',
311
                    cls: 'borderLookup',
312
                    border: false,
313
                    MaxHeigth: '30',
314
                    scroll: true,
315
                    isLookup: true,
316
                    name: "formLookupFilter",
317
                    tableName: this.tableName,
318
                    buttons: [{
319
                        text: 'Search',
320
                        //iconCls : 'fa-edit',
321
                        //style : 'font-family: FontAwesome',
322
                        handler: function () {
323

    
324
                            var store = Ext.data.StoreManager.lookup('lookupStore');
325
                            var form = Ext.ComponentQuery.query('[name=formLookupFilter]')[0].getForm();
326
                            grid = Ext.ComponentQuery.query('[name=gridLookup]')[0];
327
                            var values_ = form.getValues();
328
                            var fields_ = form.getFields().items;
329
                            var param_ = '';
330
                            for (var i = 0; i < fields_.length; i++) {
331
                                var val_ = form.getFields().items[i].getValue();
332
                                var xtype_ = form.getFields().items[i].xtype;
333
                                var oprator_ = '[like]';
334
                                if (xtype_ == 'combobox' || xtype_ == 'combo' || xtype_ == 'minovacombo' || xtype_ == 'minovacombobox') {
335
                                    oprator_ = '[Equal]';
336
                                }
337
                                if (xtype_ == 'datefield') {
338
                                    if (form.getFields().items[i].name == 'StartDate' || form.getFields().items[i].name == 'ValidForm') {
339
                                        oprator_ = '[LessThanEqual]';
340
                                    } else {
341
                                        oprator_ = '[GreaterThanEqual]';
342
                                    }
343
                                }
344
                                if (val_ != 'undefined' && val_ != "" && val_ != null) {
345
                                    param_ = param_ + ',' + form.getFields().items[i].name + oprator_ + val_;
346
                                }
347
                            }
348

    
349
                            if (SearchFunction_ != undefined && SearchFunction_ != "") {
350
                                eval(SearchFunction_);
351
                            } else {
352
                                store.proxy.extraParams = {
353
                                    tableName: grid.tableName,
354
                                    param: param_,
355
                                    menuId: MinovaUtil.GetMenuID()
356
                                };
357
                            }
358
                            store.removeAll();
359
                            store.reload();
360
                            store.loadPage(1);
361
                        }
362

    
363
                    }
364
                    ],
365
                }, {
366
                    xtype: 'minovagrid1',
367
                    isLookup: true,
368
                    autoLoad: false,
369
                    minHeight: 240,
370
                    height: 340,
371
                    tableName: this.tableName,
372
                    param: '',
373
                    //name: 'gridForm' + this.tableName,
374
                    name: 'gridLookup',
375
                    hidebutton: 0,
376
                    pagesize: 25,
377
                    storename: 'lookupStore',
378
                    listeners: {
379
                        itemdblclick: function (g) {
380
                            var LookupFunction = LookupFunction_;
381

    
382
                            var me = this;
383
                            var selection = this.getView().getSelectionModel().getSelection()[0];
384
                            var pnlMain = Ext.ComponentQuery.query('[name=PanelMdDetail]')[0];
385
                            var name_ = 'form[name=' + formtarget_ + ']';
386
                            if (pnlMain) {
387
                                name_ = 'form[name=' + formtarget_ + pnlMain.nameTable + ']';
388
                            }
389

    
390
                            var form_ = Ext.ComponentQuery.query(name_)[0].getForm();
391
                            var mainLookup = Ext.ComponentQuery.query('[name=lookupMain]')[0];
392
                            var targetField = mainLookup.fieldTarget;
393
                            if (mainLookup.isGrid) {
394
                                if (targetField) {
395
                                    targetField = targetField.split('$')
396
                                    var dt = targetField[0].split(',');
397
                                    var fieldValue = targetField[1].split(',');
398
                                    if (fieldValue.length > 0) {
399
                                        for (i in dt) {
400
                                            field_ = dt[i];
401
                                            Ext.ComponentQuery.query('[id=' + 'grid' + field_ + ']')[0].setValue(eval('selection.data.' + fieldValue[i]))
402
                                        }
403
                                    } else {
404
                                        for (i in dt) {
405
                                            field_ = dt[i];
406
                                            Ext.ComponentQuery.query('[id=' + 'grid' + field_ + ']')[0].setValue(eval('selection.data.' + field_))
407
                                        }
408
                                    }
409

    
410
                                }
411
                            } else { // untuk form
412
                                if (targetField) {
413
                                    var dt = targetField.split(',');
414
                                    var fieldValue = mainLookup.fieldValue.split(',');
415
                                    if (fieldValue.length > 0) {
416
                                        for (i in dt) {
417
                                            field_ = dt[i];
418
                                            Ext.ComponentQuery.query('[name=' + field_ + ']')[0].setValue(eval('selection.data.' + fieldValue[i]))
419
                                        }
420
                                    } else {
421
                                        for (i in dt) {
422
                                            field_ = dt[i];
423
                                            Ext.ComponentQuery.query('[name=' + field_ + ']')[0].setValue(eval('selection.data.' + field_))
424
                                        }
425
                                    }
426
                                } else {
427
                                    form_.setValues(selection.data);
428
                                }
429
                            }
430
                            eval(LookupFunction);
431
                            mainLookup.destroy();
432
                        },
433
                        beforeedit: function (grid) {
434
                            return false;
435
                        }
436
                    },
437
                    dockedItems: [{
438
                        xtype: 'pagingtoolbar',
439
                        store: 'lookupStore',
440
                        dock: 'bottom',
441
                        pageSize: 25,
442
                        displayInfo: true
443
                    }
444
                    ]
445

    
446
                }, ]
447
            }).show();
448
        }
449
        //Ext.create('Ext.window.Window', {
450
        //    title: 'Lookup - ' + this.fieldLabel,
451
        //    height: 530,
452
        //    width: 500,
453
        //    fieldTarget: fieldTarget_,
454
        //    fieldValue: fieldValue_,
455
        //    isGrid: isGrid_,
456
        //    name: 'lookupMain',
457
        //    //modal: true,
458
        //    listeners: {
459
        //        'beforeshow': function (g) {
460
        //            pnl.mask('Loading...');
461
        //            setTimeout(function () {
462
        //                pnl.unmask();
463
        //            }, 100);
464
        //        }
465
        //    },
466
        //    items: [{
467
        //        xtype: 'minovaform',
468
        //        bodyBorder: false,
469
        //        MaxHeigth: '100',
470
        //        cls: 'borderLookup',
471
        //        border: false,
472
        //        MaxHeigth: '30',
473
        //        scroll: true,
474
        //        isLookup: true,
475
        //        name: "formLookupFilter",
476
        //        tableName: this.tableName,
477
        //        buttons: [{
478
        //            text: 'Search',
479
        //            //iconCls : 'fa-edit',
480
        //            //style : 'font-family: FontAwesome',
481
        //            handler: function () {
482
        //                var store = Ext.data.StoreManager.lookup('lookupStore');
483
        //                var form = Ext.ComponentQuery.query('[name=formLookupFilter]')[0].getForm();
484
        //                grid = Ext.ComponentQuery.query('[name=gridLookup]')[0];
485
        //                var values_ = form.getValues();
486
        //                var fields_ = form.getFields().items;
487
        //                var param_ = '';
488
        //                for (var i = 0; i < fields_.length; i++) {
489
        //                    var val_ = form.getFields().items[i].getValue();
490
        //                    var xtype_ = form.getFields().items[i].xtype;
491
        //                    var oprator_ = '[like]';
492
        //                    if (xtype_ == 'combobox' || xtype_ == 'combo' || xtype_ == 'minovacombo' || xtype_ == 'minovacombobox') {
493
        //                        oprator_ = '[Equal]';
494
        //                    }
495
        //                    if (xtype_ == 'datefield') {
496
        //                        if (form.getFields().items[i].name == 'StartDate' || form.getFields().items[i].name == 'ValidForm') {
497
        //                            oprator_ = '[LessThanEqual]';
498
        //                        } else {
499
        //                            oprator_ = '[GreaterThanEqual]';
500
        //                        }
501
        //                    }
502
        //                    if (val_ != 'undefined' && val_ != "" && val_ != null) {
503
        //                        param_ = param_ + ',' + form.getFields().items[i].name + oprator_ + val_;
504
        //                    }
505
        //                }
506
        //                store.proxy.extraParams = {
507
        //                    tableName: grid.tableName,
508
        //                    param: param_
509
        //                };
510
        //                store.removeAll();
511
        //                store.reload();
512
        //                store.loadPage(1);
513
        //            }
514

    
515
        //        }
516
        //        ],
517
        //    }, {
518
        //        xtype: 'minovagrid1',
519
        //        isLookup: true,
520
        //        autoLoad: false,
521
        //        minHeight: 280,
522
        //        height: 380,
523
        //        tableName: this.tableName,
524
        //        param: '',
525
        //        //name: 'gridForm' + this.tableName,
526
        //        name: 'gridLookup',
527
        //        hidebutton: 0,
528
        //        pagesize: 25,
529
        //        storename: 'lookupStore',
530
        //        listeners: {
531
        //            itemdblclick: function (g) {
532
        //                var me = this;
533
        //                var selection = this.getView().getSelectionModel().getSelection()[0];
534
        //                var name_ = 'form[name=' + formtarget_ + ']';
535
        //                var form_ = Ext.ComponentQuery.query(name_)[0].getForm();
536
        //                var mainLookup = Ext.ComponentQuery.query('[name=lookupMain]')[0];
537
        //                var targetField = mainLookup.fieldTarget;
538
        //                if (mainLookup.isGrid) {
539
        //                    if (targetField) {
540
        //                        targetField = targetField.split('$')
541
        //                        var dt = targetField[0].split(',');
542
        //                        var fieldValue = targetField[1].split(',');
543
        //                        if (fieldValue.length > 0) {
544
        //                            for (i in dt) {
545
        //                                field_ = dt[i];
546
        //                                Ext.ComponentQuery.query('[id=' + 'grid' + field_ + ']')[0].setValue(eval('selection.data.' + fieldValue[i]))
547
        //                            }
548
        //                        } else {
549
        //                            for (i in dt) {
550
        //                                field_ = dt[i];
551
        //                                Ext.ComponentQuery.query('[id=' + 'grid' + field_ + ']')[0].setValue(eval('selection.data.' + field_))
552
        //                            }
553
        //                        }
554

    
555

    
556
        //                    }
557
        //                }
558
        //                else {// untuk form
559
        //                    if (targetField) {
560
        //                        var dt = targetField.split(',');
561
        //                        var fieldValue = mainLookup.fieldValue.split(',');
562
        //                        if (fieldValue.length > 0) {
563
        //                            for (i in dt) {
564
        //                                field_ = dt[i];
565
        //                                Ext.ComponentQuery.query('[name=' + field_ + ']')[0].setValue(eval('selection.data.' + fieldValue[i]))
566
        //                            }
567
        //                        } else {
568
        //                            for (i in dt) {
569
        //                                field_ = dt[i];
570
        //                                Ext.ComponentQuery.query('[name=' + field_ + ']')[0].setValue(eval('selection.data.' + field_))
571
        //                            }
572
        //                        }
573
        //                    }
574
        //                    else {
575
        //                        form_.setValues(selection.data);
576
        //                    }
577
        //                }
578

    
579
        //                mainLookup.destroy();
580
        //            },
581
        //            beforeedit: function (grid) {
582
        //                return false;
583
        //            }
584
        //        },
585
        //        dockedItems: [{
586
        //            xtype: 'pagingtoolbar',
587
        //            store: 'lookupStore',
588
        //            dock: 'bottom',
589
        //            pageSize: 25,
590
        //            displayInfo: true
591
        //        }
592
        //        ]
593

    
594
        //    }, ]
595
        //}).show();
596

    
597
    },
598
    onTrigger1Click: function (event) {
599
        var me = this;
600
        if (me.hideTrigger) {
601
            return;
602
        }
603
        me.setValue("");
604
        me.fireEvent('cleartriggerclick', me, event);
605
    },
606

    
607
});
608

    
609
Ext.define('MinovaUtil.MinovaES.MinovaLookupGrid', {
610
    extend: 'Ext.form.field.Trigger',
611
    alias: ['widget.minovalookupgrid', 'widget.minovalookupgrid2'],
612
    tableName: undefined,
613
    param: undefined,
614
    formtarget: undefined,
615
    anchor: '50%',
616
    pagesize: undefined,
617
    fieldTarget: undefined,
618
    fieldValue: undefined,
619
    isGrid: undefined,
620
    isMultiSelect: undefined,
621
    LookupFunction: undefined,
622
    SearchFunction: undefined,
623
    trigger1Cls: Ext.baseCSSPrefix + 'form-clear-trigger',
624
    trigger2Cls: Ext.baseCSSPrefix + 'form-search-trigger',
625
    //clearCls: 'x-form-search-clear',
626
    fieldGrid: undefined,
627

    
628
    onTrigger1Click: function (event) {
629
        var me = this;
630
        if (me.hideTrigger) {
631
            return;
632
        }
633
        me.setValue("");
634
        me.setRawValue("");
635
        me.fireEvent('cleartriggerclick', me, event);
636
    },
637
    //onTrigger1Click: function (field) {
638
    //    Ext.Msg.alert("Trigger 1", "Trigger One!!!");
639
    //},
640
    setValue: function (v) {
641
        var me = this;
642
        var value = v;
643
        this.value = '';
644
        this.value = v;
645
        me.setRawValue(v);
646
        if (value != "" && value != undefined) {
647
            data_ = undefined;
648
            Ext.Ajax.request({
649
                async: false,
650
                method: 'POST',
651
                url: '/UserControl/GetStore',
652
                params: {
653
                    tableName: 'PDSCMTABLE',
654
                    param: this.tableName + ',' + v + ',hasil'
655
                },
656
                success: function (response) {
657
                    var results = Ext.decode(response.responseText);
658
                    data_ = results.data
659
                    if (data_ != null) {
660
                        if (data_.length > 0) {
661
                            me.setRawValue(v + ' - ' + data_[0].hasil);
662

    
663
                        }
664
                    }
665

    
666
                }
667
            });
668
        }
669
        //if (me.getRawValue() == "") {
670
        //    me.value(v);
671
        //    me.setRawValue(v);
672
        //}
673
    },
674
    getValue: function () {
675
        var me = this;
676
        var hasil = this.value;
677
        if (this.valData) {
678
            hasil = this.valData;
679
        }
680
        if (hasil == undefined) {
681
            hasil = me.getRawValue();
682
        }
683
        return hasil;
684
    },
685
    getSubmitValue: function () {
686
        var me = this;
687
        var hasil = this.value;
688
        if (this.valData) {
689
            hasil = this.valData;
690
        }
691
        if (hasil == undefined) {
692
            hasil = me.getRawValue();
693
        }
694
        return hasil;
695
    },
696
    initComponent: function () {
697
        //var formtarget_ = this.formtarget;
698
        var pagesize = this.pagesize;
699
        var tableName = this.tableName;
700
        var fieldGrid_ = this.fieldGrid;
701
        this.callParent();
702
    },
703
    onTrigger2Click: function () {
704
        //alert('asa')
705
        var isGrid_ = this.isGrid;
706
        var fieldTarget_ = this.fieldTarget;
707
        var formtarget_ = this.formtarget;
708
        var fieldValue_ = this.fieldValue;
709
        var tableName = this.tableName;
710
        var LookupFunction_ = this.LookupFunction;
711
        var SearchFunction_ = this.SearchFunction;
712
        var fieldGrid_ = this.fieldGrid;
713
        var pnl = Ext.ComponentQuery.query('[name=' + formtarget_ + ']')[0];
714

    
715
        if (tableName == 'PDSPY0006') {
716
            Ext.create('Ext.window.Window', {
717
                title: 'Lookup - ' + this.fieldLabel,
718
                //hamid
719
                controller: 'rdlreportPayResult',
720
                //end hamid
721
                height: 530,
722
                width: 500,
723
                fieldTarget: fieldTarget_,
724
                fieldValue: fieldValue_,
725
                isGrid: isGrid_,
726
                name: 'lookupMain',
727
                //modal: true,
728
                listeners: {
729
                    'beforeshow': function (g) {
730
                        pnl.mask('Loading...');
731
                        setTimeout(function () {
732
                            pnl.unmask();
733
                        }, 100);
734
                    }
735
                },
736
                items: [{
737
                    xtype: 'minovaform',
738
                    bodyBorder: false,
739
                    MaxHeigth: '100',
740
                    cls: 'borderLookup',
741
                    border: false,
742
                    scroll: true,
743
                    isLookup: true,
744
                    name: "formLookupFilter",
745
                    tableName: this.tableName,
746
                    buttons: [{
747
                        text: 'Search',
748
                        //iconCls : 'fa-edit',
749
                        //style : 'font-family: FontAwesome',
750
                        handler: function () {
751
                            var store = Ext.data.StoreManager.lookup('lookupStore');
752
                            var form = Ext.ComponentQuery.query('[name=formLookupFilter]')[0].getForm();
753
                            grid = Ext.ComponentQuery.query('[name=gridLookup]')[0];
754
                            var values_ = form.getValues();
755
                            var fields_ = form.getFields().items;
756
                            var param_ = '';
757
                            for (var i = 0; i < fields_.length; i++) {
758
                                var val_ = form.getFields().items[i].getValue();
759
                                var xtype_ = form.getFields().items[i].xtype;
760
                                var oprator_ = '[like]';
761
                                if (xtype_ == 'combobox' || xtype_ == 'combo' || xtype_ == 'minovacombo' || xtype_ == 'minovacombobox') {
762
                                    oprator_ = '[Equal]';
763
                                }
764
                                if (xtype_ == 'datefield') {
765
                                    if (form.getFields().items[i].name == 'StartDate' || form.getFields().items[i].name == 'ValidForm') {
766
                                        oprator_ = '[LessThanEqual]';
767
                                    } else {
768
                                        oprator_ = '[GreaterThanEqual]';
769
                                    }
770
                                }
771
                                if (val_ != 'undefined' && val_ != "" && val_ != null) {
772
                                    param_ = param_ + ',' + form.getFields().items[i].name + oprator_ + val_;
773
                                }
774
                            }
775
                            store.proxy.extraParams = {
776
                                tableName: grid.tableName,
777
                                param: param_,
778
                                menuId: MinovaUtil.GetMenuID()
779
                            };
780
                            store.removeAll();
781
                            store.reload();
782
                            store.loadPage(1);
783
                        }
784

    
785
                    }
786
                    ],
787
                }, {
788
                    xtype: 'minovagrid2',
789
                    isLookup: true,
790
                    autoLoad: false,
791
                    minHeight: 280,
792
                    fieldGrid: fieldGrid_,
793
                    height: 380,
794
                    tableName: this.tableName,
795
                    param: '',
796
                    //name: 'gridForm' + this.tableName,
797
                    name: 'gridLookup',
798
                    hidebutton: 0,
799
                    pagesize: 25,
800
                    storename: 'lookupStore',
801
                    listeners: {
802
                        itemdblclick: function (g) {
803

    
804
                            var me = this;
805

    
806
                            var selection = this.getView().getSelectionModel().getSelection()[0];
807
                            var name_ = 'form[name=' + formtarget_ + ']';
808
                            var form_ = Ext.ComponentQuery.query(name_)[0].getForm();
809
                            var mainLookup = Ext.ComponentQuery.query('[name=lookupMain]')[0];
810
                            var targetField = mainLookup.fieldTarget;
811
                            if (mainLookup.isGrid) {
812
                                var b = Ext.ComponentQuery.query('[fieldGrid=' + me.fieldGrid + ']')[0];
813
                                if (b) {
814
                                    b.setValue(eval('selection.data.' + me.fieldGrid));
815
                                }
816
                                if (targetField) {
817
                                    targetField = targetField.split('$')
818
                                    var dt = targetField[0].split(',');
819
                                    var fieldValue = targetField[1].split(',');
820
                                    if (fieldValue.length > 0) {
821
                                        for (i in dt) {
822
                                            field_ = dt[i];
823
                                            Ext.ComponentQuery.query('[id=' + 'grid' + field_ + ']')[0].setValue(eval('selection.data.' + fieldValue[i]))
824
                                        }
825
                                    } else {
826
                                        for (i in dt) {
827
                                            field_ = dt[i];
828
                                            Ext.ComponentQuery.query('[id=' + 'grid' + field_ + ']')[0].setValue(eval('selection.data.' + field_))
829
                                        }
830
                                    }
831
                                }
832
                            }
833
                            //else {// untuk form
834
                            if (targetField) {
835
                                var dt = targetField.split(',');
836
                                var fieldValue = mainLookup.fieldValue.split(',');
837
                                if (fieldValue.length > 0) {
838
                                    for (i in dt) {
839
                                        field_ = dt[i];
840
                                        Ext.ComponentQuery.query('[name=' + field_ + ']')[0].setValue(eval('selection.data.' + fieldValue[i]))
841
                                    }
842
                                } else {
843
                                    for (i in dt) {
844
                                        field_ = dt[i];
845
                                        Ext.ComponentQuery.query('[name=' + field_ + ']')[0].setValue(eval('selection.data.' + field_))
846
                                    }
847
                                }
848
                            } else {
849
                                form_.setValues(selection.data);
850
                            }
851
                            //}
852

    
853
                            mainLookup.destroy();
854
                        },
855
                        beforeedit: function (grid) {
856
                            return false;
857
                        }
858
                    },
859
                    dockedItems: [{
860
                        xtype: 'pagingtoolbar',
861
                        store: 'lookupStore',
862
                        dock: 'bottom',
863
                        pageSize: 25,
864
                        displayInfo: true
865
                    }
866
                    ]
867

    
868
                }, ]
869
            }).show();
870
        } else {
871
            // hamid
872
            Ext.create('Ext.window.Window', {
873
                title: 'Lookup - ' + this.fieldLabel,
874
                height: 560,
875
                width: 500,
876
                fieldTarget: fieldTarget_,
877
                fieldValue: fieldValue_,
878
                isGrid: isGrid_,
879
                name: 'lookupMain',
880
                //modal: true,
881
                listeners: {
882
                    'beforeshow': function (g) {
883
                        pnl.mask('Loading...');
884
                        setTimeout(function () {
885
                            pnl.unmask();
886
                        }, 100);
887
                    }
888
                },
889
                items: [{
890
                    xtype: 'minovaform',
891
                    bodyBorder: false,
892
                    MaxHeigth: '100',
893
                    cls: 'borderLookup',
894
                    border: false,
895
                    MaxHeigth: '30',
896
                    scroll: true,
897
                    isLookup: true,
898
                    name: "formLookupFilter",
899
                    tableName: this.tableName,
900
                    buttons: [{
901
                        text: 'Search',
902
                        //iconCls : 'fa-edit',
903
                        //style : 'font-family: FontAwesome',
904
                        handler: function () {
905

    
906
                            var store = Ext.data.StoreManager.lookup('lookupStore');
907
                            var form = Ext.ComponentQuery.query('[name=formLookupFilter]')[0].getForm();
908
                            grid = Ext.ComponentQuery.query('[name=gridLookup]')[0];
909
                            var values_ = form.getValues();
910
                            var fields_ = form.getFields().items;
911
                            var param_ = '';
912
                            for (var i = 0; i < fields_.length; i++) {
913
                                var val_ = form.getFields().items[i].getValue();
914
                                var xtype_ = form.getFields().items[i].xtype;
915
                                var oprator_ = '[like]';
916
                                if (xtype_ == 'combobox' || xtype_ == 'combo' || xtype_ == 'minovacombo' || xtype_ == 'minovacombobox') {
917
                                    oprator_ = '[Equal]';
918
                                }
919
                                if (xtype_ == 'datefield') {
920
                                    if (form.getFields().items[i].name == 'StartDate' || form.getFields().items[i].name == 'ValidForm') {
921
                                        oprator_ = '[LessThanEqual]';
922
                                    } else {
923
                                        oprator_ = '[GreaterThanEqual]';
924
                                    }
925
                                }
926
                                if (val_ != 'undefined' && val_ != "" && val_ != null) {
927
                                    param_ = param_ + ',' + form.getFields().items[i].name + oprator_ + val_;
928
                                }
929
                            }
930

    
931
                            if (SearchFunction_ != undefined && SearchFunction_ != "") {
932
                                eval(SearchFunction_);
933
                            } else {
934
                                store.proxy.extraParams = {
935
                                    tableName: grid.tableName,
936
                                    param: param_,
937
                                    menuId: MinovaUtil.GetMenuID()
938
                                };
939
                            }
940
                            store.removeAll();
941
                            store.reload();
942
                            store.loadPage(1);
943
                        }
944

    
945
                    }
946
                    ],
947
                }, {
948
                    xtype: 'minovagrid2',
949
                    isLookup: true,
950
                    autoLoad: false,
951
                    minHeight: 240,
952
                    height: 340,
953
                    tableName: this.tableName,
954
                    param: '',
955
                    //name: 'gridForm' + this.tableName,
956
                    name: 'gridLookup',
957
                    hidebutton: 0,
958
                    pagesize: 25,
959
                    storename: 'lookupStore',
960
                    fieldGrid: fieldGrid_,
961
                    listeners: {
962
                        itemdblclick: function (g) {
963
                            var LookupFunction = LookupFunction_;
964

    
965
                            var me = this;
966
                            var selection = this.getView().getSelectionModel().getSelection()[0];
967
                            var pnlMain = Ext.ComponentQuery.query('[name=PanelMdDetail]')[0];
968
                            var name_ = 'form[name=' + formtarget_ + ']';
969
                            if (pnlMain) {
970
                                name_ = 'form[name=' + formtarget_ + pnlMain.nameTable + ']';
971
                            }
972

    
973
                            var formM = Ext.ComponentQuery.query(name_)[0];
974
                            var form_ = null;
975
                            if (!formM) {
976
                                form_ = Ext.ComponentQuery.query('[name=MinovaGridFormEdit]')[0].getForm();
977
                            } else {
978
                                form_ = formM.getForm();
979
                            }
980
                            var mainLookup = Ext.ComponentQuery.query('[name=lookupMain]')[0];
981
                            var targetField = mainLookup.fieldTarget;
982
                            if (mainLookup.isGrid) {
983
                                var b = Ext.ComponentQuery.query('[fieldGrid=' + me.fieldGrid + ']')[0];
984
                                if (b) {
985
                                    b.setValue(eval('selection.data.' + me.fieldGrid));
986
                                }
987
                                if (targetField) {
988
                                    targetField = targetField.split('$')
989
                                    var dt = targetField[0].split(',');
990
                                    var fieldValue = targetField[1].split(',');
991
                                    if (fieldValue.length > 0) {
992
                                        for (i in dt) {
993
                                            field_ = dt[i];
994
                                            Ext.ComponentQuery.query('[id=' + 'grid' + field_ + ']')[0].setValue(eval('selection.data.' + fieldValue[i]))
995
                                        }
996
                                    } else {
997
                                        for (i in dt) {
998
                                            field_ = dt[i];
999
                                            Ext.ComponentQuery.query('[id=' + 'grid' + field_ + ']')[0].setValue(eval('selection.data.' + field_))
1000
                                        }
1001
                                    }
1002

    
1003
                                }
1004
                            } else { // untuk form
1005
                                if (targetField) {
1006
                                    var dt = targetField.split(',');
1007
                                    var fieldValue = mainLookup.fieldValue.split(',');
1008
                                    if (fieldValue.length > 0) {
1009
                                        for (i in dt) {
1010
                                            field_ = dt[i];
1011
                                            Ext.ComponentQuery.query('[name=' + field_ + ']')[0].setValue(eval('selection.data.' + fieldValue[i]))
1012
                                        }
1013
                                    } else {
1014
                                        for (i in dt) {
1015
                                            field_ = dt[i];
1016
                                            Ext.ComponentQuery.query('[name=' + field_ + ']')[0].setValue(eval('selection.data.' + field_))
1017
                                        }
1018
                                    }
1019
                                } else {
1020
                                    form_.setValues(selection.data);
1021
                                }
1022
                            }
1023
                            eval(LookupFunction);
1024
                            mainLookup.destroy();
1025
                        },
1026
                        beforeedit: function (grid) {
1027
                            return false;
1028
                        }
1029
                    },
1030
                    dockedItems: [{
1031
                        xtype: 'pagingtoolbar',
1032
                        store: 'lookupStore',
1033
                        dock: 'bottom',
1034
                        pageSize: 25,
1035
                        displayInfo: true
1036
                    }
1037
                    ]
1038

    
1039
                }, ]
1040
            }).show();
1041
        }
1042
        //Ext.create('Ext.window.Window', {
1043
        //    title: 'Lookup - ' + this.fieldLabel,
1044
        //    height: 530,
1045
        //    width: 500,
1046
        //    fieldTarget: fieldTarget_,
1047
        //    fieldValue: fieldValue_,
1048
        //    isGrid: isGrid_,
1049
        //    name: 'lookupMain',
1050
        //    //modal: true,
1051
        //    listeners: {
1052
        //        'beforeshow': function (g) {
1053
        //            pnl.mask('Loading...');
1054
        //            setTimeout(function () {
1055
        //                pnl.unmask();
1056
        //            }, 100);
1057
        //        }
1058
        //    },
1059
        //    items: [{
1060
        //        xtype: 'minovaform',
1061
        //        bodyBorder: false,
1062
        //        MaxHeigth: '100',
1063
        //        cls: 'borderLookup',
1064
        //        border: false,
1065
        //        MaxHeigth: '30',
1066
        //        scroll: true,
1067
        //        isLookup: true,
1068
        //        name: "formLookupFilter",
1069
        //        tableName: this.tableName,
1070
        //        buttons: [{
1071
        //            text: 'Search',
1072
        //            //iconCls : 'fa-edit',
1073
        //            //style : 'font-family: FontAwesome',
1074
        //            handler: function () {
1075
        //                var store = Ext.data.StoreManager.lookup('lookupStore');
1076
        //                var form = Ext.ComponentQuery.query('[name=formLookupFilter]')[0].getForm();
1077
        //                grid = Ext.ComponentQuery.query('[name=gridLookup]')[0];
1078
        //                var values_ = form.getValues();
1079
        //                var fields_ = form.getFields().items;
1080
        //                var param_ = '';
1081
        //                for (var i = 0; i < fields_.length; i++) {
1082
        //                    var val_ = form.getFields().items[i].getValue();
1083
        //                    var xtype_ = form.getFields().items[i].xtype;
1084
        //                    var oprator_ = '[like]';
1085
        //                    if (xtype_ == 'combobox' || xtype_ == 'combo' || xtype_ == 'minovacombo' || xtype_ == 'minovacombobox') {
1086
        //                        oprator_ = '[Equal]';
1087
        //                    }
1088
        //                    if (xtype_ == 'datefield') {
1089
        //                        if (form.getFields().items[i].name == 'StartDate' || form.getFields().items[i].name == 'ValidForm') {
1090
        //                            oprator_ = '[LessThanEqual]';
1091
        //                        } else {
1092
        //                            oprator_ = '[GreaterThanEqual]';
1093
        //                        }
1094
        //                    }
1095
        //                    if (val_ != 'undefined' && val_ != "" && val_ != null) {
1096
        //                        param_ = param_ + ',' + form.getFields().items[i].name + oprator_ + val_;
1097
        //                    }
1098
        //                }
1099
        //                store.proxy.extraParams = {
1100
        //                    tableName: grid.tableName,
1101
        //                    param: param_
1102
        //                };
1103
        //                store.removeAll();
1104
        //                store.reload();
1105
        //                store.loadPage(1);
1106
        //            }
1107

    
1108
        //        }
1109
        //        ],
1110
        //    }, {
1111
        //        xtype: 'minovagrid1',
1112
        //        isLookup: true,
1113
        //        autoLoad: false,
1114
        //        minHeight: 280,
1115
        //        height: 380,
1116
        //        tableName: this.tableName,
1117
        //        param: '',
1118
        //        //name: 'gridForm' + this.tableName,
1119
        //        name: 'gridLookup',
1120
        //        hidebutton: 0,
1121
        //        pagesize: 25,
1122
        //        storename: 'lookupStore',
1123
        //        listeners: {
1124
        //            itemdblclick: function (g) {
1125
        //                var me = this;
1126
        //                var selection = this.getView().getSelectionModel().getSelection()[0];
1127
        //                var name_ = 'form[name=' + formtarget_ + ']';
1128
        //                var form_ = Ext.ComponentQuery.query(name_)[0].getForm();
1129
        //                var mainLookup = Ext.ComponentQuery.query('[name=lookupMain]')[0];
1130
        //                var targetField = mainLookup.fieldTarget;
1131
        //                if (mainLookup.isGrid) {
1132
        //                    if (targetField) {
1133
        //                        targetField = targetField.split('$')
1134
        //                        var dt = targetField[0].split(',');
1135
        //                        var fieldValue = targetField[1].split(',');
1136
        //                        if (fieldValue.length > 0) {
1137
        //                            for (i in dt) {
1138
        //                                field_ = dt[i];
1139
        //                                Ext.ComponentQuery.query('[id=' + 'grid' + field_ + ']')[0].setValue(eval('selection.data.' + fieldValue[i]))
1140
        //                            }
1141
        //                        } else {
1142
        //                            for (i in dt) {
1143
        //                                field_ = dt[i];
1144
        //                                Ext.ComponentQuery.query('[id=' + 'grid' + field_ + ']')[0].setValue(eval('selection.data.' + field_))
1145
        //                            }
1146
        //                        }
1147

    
1148

    
1149
        //                    }
1150
        //                }
1151
        //                else {// untuk form
1152
        //                    if (targetField) {
1153
        //                        var dt = targetField.split(',');
1154
        //                        var fieldValue = mainLookup.fieldValue.split(',');
1155
        //                        if (fieldValue.length > 0) {
1156
        //                            for (i in dt) {
1157
        //                                field_ = dt[i];
1158
        //                                Ext.ComponentQuery.query('[name=' + field_ + ']')[0].setValue(eval('selection.data.' + fieldValue[i]))
1159
        //                            }
1160
        //                        } else {
1161
        //                            for (i in dt) {
1162
        //                                field_ = dt[i];
1163
        //                                Ext.ComponentQuery.query('[name=' + field_ + ']')[0].setValue(eval('selection.data.' + field_))
1164
        //                            }
1165
        //                        }
1166
        //                    }
1167
        //                    else {
1168
        //                        form_.setValues(selection.data);
1169
        //                    }
1170
        //                }
1171

    
1172
        //                mainLookup.destroy();
1173
        //            },
1174
        //            beforeedit: function (grid) {
1175
        //                return false;
1176
        //            }
1177
        //        },
1178
        //        dockedItems: [{
1179
        //            xtype: 'pagingtoolbar',
1180
        //            store: 'lookupStore',
1181
        //            dock: 'bottom',
1182
        //            pageSize: 25,
1183
        //            displayInfo: true
1184
        //        }
1185
        //        ]
1186

    
1187
        //    }, ]
1188
        //}).show();
1189

    
1190
    },
1191
});
1192
Ext.define('MinovaUtil.MinovaES.MinovaComboDisplay', {
1193
    extend: 'Ext.form.field.Display',
1194
    alias: ['widget.minovacombodisplay'],
1195
    initComponent: function () {
1196
        this.callParent(arguments);
1197
    },
1198

    
1199
    defaultRenderer: function (value) {
1200
        if (typeof(this.store) !== 'object') {
1201
            this.store = Ext.data.StoreManager.lookup(this.store);
1202
        }
1203
        var idx = this.store.findExact(this.valueField, value);
1204
        if (this.store.getAt(idx)) {
1205
            var result = this.store.getAt(idx).get(this.displayField);
1206
            value = result ? result : value;
1207
        }
1208
        this.setRawValue(value);
1209

    
1210
    }
1211
});
1212
Ext.define('MinovaUtil.MinovaES.DisplayDate', {
1213
    extend: 'Ext.form.field.Display',
1214
    alias: ['widget.minovadisplaydate'],
1215
    undefinedText: '&#160;',
1216
    setValue: function (v) {
1217
        var value = v;
1218
        if (value === undefined) {
1219
            return this.undefinedText;
1220
        }
1221
        if (value === null) {
1222
            return this.setRawValue(null);
1223
        }
1224
        var d = value.substring(6, 8);
1225
        var m = value.substring(4, 6);
1226
        var y = value.substring(0, 4);
1227

    
1228
        var hasil = d + '/' + m + '/' + y;
1229
        //this.setRawValue(hasil);
1230
        this.setValue(hasil);
1231
    },
1232
    getRawValue: function () {
1233
        return this.getValue();
1234
    },
1235
    getValue: function () {
1236
        var value = this.rawValue;
1237
        var hasil = null;
1238
        if (value != undefined) {
1239
            var d = value.substring(0, 2);
1240
            var m = value.substring(3, 5);
1241
            var y = value.substring(6, 10);
1242

    
1243
            hasil = y + m + d;
1244
        }
1245
        return hasil;
1246
    }
1247
});
1248
Ext.define('MinovaUtil.MinovaES.DisplaySysDateTime', {
1249
    extend: 'Ext.form.field.Display',
1250
    alias: ['widget.minovadisplaysysdatetime'],
1251
    undefinedText: '&#160;',
1252
    //hamid
1253
    listeners: {
1254
        change: function (f) {
1255
            var field = f.getValue()
1256
            var value = field;
1257
            if (value === "" || value === undefined) {
1258
                return this.setRawValue("");
1259
            } else {
1260
                var d = value.substring(6, 8);
1261
                var m = value.substring(4, 6);
1262
                var y = value.substring(0, 4);
1263
                var h = value.substring(8, 10);
1264
                var mt = value.substring(10, 12);
1265
                var s = value.substring(12, 14);
1266
                var hasil = d + '/' + m + '/' + y + '  ' + '  ' + h + ':' + mt + ':' + s;
1267

    
1268
            }
1269

    
1270
            f.setRawValue(hasil)
1271
        },
1272
    },
1273
    //end
1274

    
1275
});
1276
Ext.define('MinovaUtil.MinovaES.MinovaButton', {
1277
    extend: 'Ext.button.Button',
1278
    alias: ['widget.minovabutton', 'widget.MinovaButton'],
1279
    nextid: undefined,
1280
    parid: undefined,
1281
    page: undefined,
1282
    start: undefined,
1283
    limit: 1,
1284
    setStart: function (value) {
1285
        var me = this;
1286
        me.start = value;
1287
        return me;
1288
    },
1289
    getStart: function () {
1290
        return this.start;
1291
    },
1292
    setNextid: function (value) {
1293
        var me = this;
1294
        me.nextid = value;
1295
        return me;
1296
    },
1297
    getNextid: function () {
1298
        return this.nextid;
1299
    },
1300
    setParid: function (value) {
1301
        var me = this;
1302
        me.parid = value;
1303
        return me;
1304
    },
1305
    getParid: function () {
1306
        return this.parid;
1307
    },
1308
    anchor: '50%',
1309
    initComponent: function () {
1310
        var me = this;
1311
        Ext.applyIf(me, {});
1312
        me.callParent(arguments);
1313
    }
1314
});
1315
Ext.define('MinovaUtil.MinovaES.MinovaComboBox', {
1316
    extend: 'Ext.form.field.ComboBox',
1317
    alias: ['widget.minovacombobox', 'widget.minovacombo'],
1318
    tableName: undefined,
1319
    param: undefined,
1320
	anyMatch: true,
1321
    anchor: '50%',
1322
    queryMode: 'local',
1323
    forceSelection: true, // cek data
1324
    initComponent: function () {
1325
        var me = this;
1326
        Ext.applyIf(me, {
1327

    
1328
            store: Ext.create('Ext.data.Store', {
1329
                storeId: 'store' + me.name,
1330
                autoLoad: true,
1331
                proxy: {
1332
                    method: 'POST',
1333
                    type: 'ajax',
1334
                    url: '/UserControl/GetStoreAuth',
1335
                    extraParams: {
1336
                        tableName: me.tableName,
1337
                        param: me.param,
1338
                        menuId: MinovaUtil.GetMenuID()
1339
                    },
1340
                    reader: {
1341
                        type: 'json',
1342
                        root: 'data'
1343
                    }
1344
                }
1345
            })
1346
        });
1347
        me.callParent(arguments);
1348
    }
1349
});
1350

    
1351
Ext.define('MinovaUtil.MinovaES.MinovaComboBoxTpl', {
1352
    extend: 'Ext.form.field.ComboBox',
1353
    alias: ['widget.minovacomboboxtpl', 'widget.minovacombotpl'],
1354
    tableName: undefined,
1355
    param: undefined,
1356
    dis1: undefined,
1357
    dis2: undefined,
1358
    anchor: '50%',
1359
    queryMode: 'local',
1360
    forceSelection: true,
1361
    tpl: Ext.create('Ext.XTemplate',
1362
		'<tpl for=".">',
1363
		'<div class="x-boundlist-item">' + this.dis1 + '</div>',
1364
		'</tpl>'),
1365
    displayTpl: Ext.create('Ext.XTemplate',
1366
		'<tpl for=".">',
1367
		+this.dis1,
1368
		'</tpl>'),
1369
    initComponent: function () {
1370
        var me = this;
1371
        Ext.applyIf(me, {
1372
            store: Ext.create('Ext.data.Store', {
1373
                storeId: 'store' + me.name,
1374
                autoLoad: true,
1375
                proxy: {
1376
                    method: 'POST',
1377
                    type: 'ajax',
1378
                    url: '/UserControl/GetStore',
1379
                    extraParams: {
1380
                        tableName: me.tableName,
1381
                        param: me.param
1382
                    },
1383
                    reader: {
1384
                        type: 'json',
1385
                        root: 'data'
1386
                    }
1387
                }
1388
            })
1389
        });
1390
        me.callParent(arguments);
1391
    }
1392
});
1393
Ext.define('MinovaUtil.MinovaES.MinovaMultiComboBox', {
1394
    extend: 'Ext.form.field.ComboBox',
1395
    alias: ['widget.minovamulticombobox', 'widget.minovamulticombo'],
1396
    tableName: undefined,
1397
    param: undefined,
1398
    anchor: '50%',
1399
    queryMode: 'local',
1400
    forceSelection: true, // cek data
1401
    multiSelect: true,
1402
    getValue: function () {
1403
        var hasil = null;
1404
        var val = this.value;
1405
        if (val != undefined) {
1406
            hasil = val.toString();
1407
        }
1408
        return hasil;
1409
    },
1410
    initComponent: function () {
1411
        var me = this;
1412
        Ext.applyIf(me, {
1413
            store: Ext.create('Ext.data.Store', {
1414
                storeId: 'store' + me.name,
1415
                autoLoad: true,
1416
                proxy: {
1417
                    method: 'POST',
1418
                    type: 'ajax',
1419
                    url: '/UserControl/GetStore',
1420
                    extraParams: {
1421
                        tableName: me.tableName,
1422
                        param: me.param
1423
                    },
1424
                    reader: {
1425
                        type: 'json',
1426
                        root: 'data'
1427
                    }
1428
                }
1429
            })
1430
        });
1431
        me.callParent(arguments);
1432
    }
1433
});
1434
Ext.define('Ext.ux.MinovaLookupGrid1', {
1435
    extend: 'Ext.form.field.Trigger',
1436
    alias: 'widget.minovalookupgrid1',
1437
    tableName: undefined,
1438
    param: undefined,
1439
    formtarget_: this.formtarget,
1440
    anchor: '50%',
1441
    pagesize: undefined,
1442
    initComponent: function () {
1443
        var target = this.formtarget;
1444
        this.callParent();
1445
    },
1446
    onTriggerClick: function () {
1447
        var count_lookup = Ext.ComponentQuery.query('[name=mainLookup]').length;
1448
        if (count_lookup == 1) {
1449
            Ext.ComponentQuery.query('[name=mainLookup]')[0].show();
1450
        } else {
1451
            var target_ = this.formtarget;
1452
            var fieldtarget = this.name;
1453
            var pagesize_ = this.pagesize;
1454
            if (pagesize_ == undefined) {
1455
                pagesize_ = 25;
1456
            }
1457
            var mainLookup = Ext.create('Ext.window.Window', {
1458
                name: 'mainLookup',
1459
                width: 500,
1460
                heigth: 300,
1461
                maxHeigth: 300,
1462
                minWidth: 400,
1463
                scroll: true,
1464
                modal: true,
1465
                title: 'Lookup - ' + this.fieldLabel,
1466
                items: [{
1467
                    xtype: 'form',
1468
                    collapsible: false,
1469
                    items: [{
1470
                        xtype: 'form',
1471
                        //width: '90%',
1472
                        name: 'formFilter',
1473
                        layout: 'column',
1474
                        dockedItems: [{
1475
                            xtype: 'toolbar',
1476
                            dock: 'bottom',
1477
                            items: [{
1478
                                xtype: 'tbfill'
1479
                            }, {
1480
                                text: 'Search',
1481
                                scope: this,
1482
                                handler: function () {
1483
                                    var store = Ext.data.StoreManager.lookup('lookupStore');
1484
                                    var form = Ext.ComponentQuery.query('[name=formFilter]')[0].getForm();
1485
                                    var values_ = form.getValues();
1486
                                    var fields_ = form.getFields().items;
1487
                                    var param_ = '';
1488
                                    for (var i = 0; i < fields_.length; i++) {
1489
                                        var val_ = form.getFields().items[i].getValue();
1490
                                        var xtype_ = form.getFields().items[i].xtype;
1491
                                        var oprator_ = '[like]';
1492
                                        if (xtype_ == 'combobox' || xtype_ == 'combo' || xtype_ == 'minovacombo' || xtype_ == 'minovacombobox') {
1493
                                            oprator_ = '[Equal]';
1494
                                        }
1495
                                        if (xtype_ == 'datefield') {
1496
                                            if (form.getFields().items[i].name == 'StartDate' || form.getFields().items[i].name == 'ValidForm') {
1497
                                                oprator_ = '[LessThanEqual]';
1498
                                            } else {
1499
                                                oprator_ = '[GreaterThanEqual]';
1500
                                            }
1501
                                        }
1502
                                        if (val_ != 'undefined' && val_ != "") {
1503
                                            param_ = param_ + ',' + form.getFields().items[i].name + oprator_ + val_;
1504
                                        }
1505
                                    }
1506
                                    store.proxy.extraParams = {
1507
                                        tableName: this.tableName,
1508
                                        param: param_
1509
                                    };
1510
                                    store.removeAll();
1511
                                    store.reload();
1512
                                    store.loadPage(1);
1513
                                }
1514
                            }, ]
1515
                        }
1516
                        ],
1517
                        defaults: {
1518
                            xtype: 'container',
1519
                            defaultType: 'textfield',
1520
                            style: 'width: 50%'
1521
                        },
1522
                        items: [{
1523
                            xtype: 'minovaform',
1524
                            bodyBorder: false,
1525
                            cls: 'borderLookup',
1526
                            border: false,
1527
                            MaxHeigth: '30',
1528
                            scroll: true,
1529
                            isLookup: 1,
1530
                            name: "formLookupFilter",
1531
                            tableName: this.tableName,
1532
                        }
1533
                        ],
1534
                    }
1535
                    ]
1536
                }, {
1537
                    xtype: 'form',
1538
                    name: 'formResult',
1539
                    title: 'Result',
1540
                    collapsible: true,
1541
                    items: [{
1542
                        xtype: "minovagrid",
1543
                        name: "lookupgrid",
1544
                        tableName: this.tableName,
1545
                        param: '',
1546
                        pagesize: pagesize_,
1547
                        storename: 'lookupStore',
1548
                        isLookup: 1,
1549
                        border: false,
1550
                        minHeight: 300,
1551
                        maxHeight: 500,
1552
                        height: 100,
1553
                        columnLines: true,
1554
                        scrollable: true,
1555
                        listeners: {
1556
                            itemdblclick: function (formtarget_) {
1557
                                var me = this;
1558
                                var selection = this.getView().getSelectionModel().getSelection()[0];
1559
                                if (target_ == null || target_ == undefined) {
1560
                                    var formtarget_ = '[name=' + fieldtarget + ']';
1561
                                    var form_ = Ext.ComponentQuery.query(formtarget_)[0];
1562
                                } else {
1563
                                    var formtarget_ = 'form[name=' + target_ + ']';
1564
                                    var form_ = Ext.ComponentQuery.query(formtarget_)[0].getForm();
1565
                                    form_.setValues(selection.data)
1566
                                }
1567
                                mainLookup.hide();
1568
                            },
1569
                            beforeedit: function (grid) {
1570
                                return false;
1571
                            }
1572
                        },
1573
                        dockedItems: [{
1574
                            xtype: 'pagingtoolbar',
1575
                            store: 'lookupStore',
1576
                            dock: 'bottom',
1577
                            pageSize: pagesize_,
1578
                            displayInfo: true
1579
                        }
1580
                        ],
1581
                    }
1582
                    ]
1583
                }
1584
                ]
1585
            }).show();
1586
        }
1587
    },
1588
});
1589
Ext.define('Ext.ux.MinovaLookupTree', {
1590
    extend: 'Ext.form.field.Trigger',
1591
    alias: 'widget.minovalookuptree',
1592
    tableName: undefined,
1593
    param: undefined,
1594
    onTriggerClick: function () {}
1595

    
1596
});
1597
Ext.define('Ext.ux.MinovaLookupFile', {
1598
    extend: 'Ext.form.field.Trigger',
1599
    alias: 'widget.minovalookupfile',
1600
    tableName: undefined,
1601
    param: undefined,
1602
    onTriggerClick: function () {}
1603

    
1604
});
1605
Ext.define('MinovaUtil.MinovaES.MinovaGrid1', {
1606
    extend: 'Ext.grid.Panel',
1607
    requires: ['Ext.grid.RowNumberer'],
1608
    alias: 'widget.minovagrid1',
1609
    //alias: ['widget.minovagrid1', 'widget.minovagrid'],
1610
    //alias: ['widget.minovagrid1', 'widget.minovagrid'],
1611
    alternateClassName: 'Ext.grid.MinovaGrid',
1612
    //controller:'orm-manage2-controller',
1613
    tableName: undefined,
1614
    isLookup: undefined,
1615
    param: undefined,
1616
    pagesize: undefined,
1617
    storename: undefined,
1618
    layoutType: undefined,
1619
    enableLocking: true,
1620
    autoLoad: undefined,
1621
    multiSelect: undefined,
1622
    getTableName: function () {
1623
        return this.tableName;
1624
    },
1625

    
1626
    initComponent: function () {
1627
        var me = this;
1628
        var cols_ = [];
1629
        var fieldeditor = {};
1630
        var hasil = null;
1631
        var autoLoad = true;
1632
        var LangID = localStorage.LangId;
1633
        var fielGrid = 'rec.GridView == 1';
1634
        var locking = true;
1635
        var checkSelection = '';
1636
        var widthLock = 250;
1637
        if (me.multiSelect) {
1638
            locking = false;
1639
            checkSelection = 'checkboxmodel';
1640
            widthLock = 40;
1641
        }
1642
        //var _url = 'GetAllField';
1643
        if (me.autoLoad == false) {
1644
            autoLoad = false;
1645
        }
1646
        parameter = null;
1647
        if (me.isLookup == 1 || me.isLookup == 'Y' || me.isLookup == true) {
1648
            parameter = "LangID='" + LangID + "',TableName='" + me.tableName + "',LookupGrid='1'";
1649
            fielGrid = 'rec.LookupGrid == 1';
1650
            locking = false;
1651

    
1652
        } else {
1653
            parameter = "LangID='" + LangID + "',TableName='" + me.tableName + "'"
1654
            //autoLoad = false;
1655
            //_url = 'GetAllFieldGridLookUp';
1656
        };
1657

    
1658
        //Ext.Ajax.request({
1659
        //	async : false,
1660
        //	method : 'POST',
1661
        //	url : '/Devt/' + _url + '?tableName=' + me.tableName,
1662
        //	success : function (response) {
1663
        //		var results = Ext.decode(response.responseText);
1664
        //		hasil = results.data;
1665
        //	}
1666
        //});
1667
        //hamid03102016
1668

    
1669
        Ext.Ajax.request({
1670
            async: false,
1671
            method: 'POST',
1672
            url: '/UserControl/GetStore',
1673
            params: {
1674
                tableName: 'PDSBS0007',
1675
                param: parameter
1676
            },
1677
            success: function (response) {
1678
                var results = Ext.decode(response.responseText);
1679
                hasil = results.data;
1680
            }
1681
        });
1682
        //end
1683

    
1684
        if (hasil.length > 0) {
1685

    
1686
            Ext.each(hasil, function (rec) {
1687
                var null_ = null;
1688
                if (rec.IsPrimaryKey == true) {
1689
                    null_ = false;
1690
                }
1691
                if (rec.IsRequired == true) {
1692
                    null_ = false;
1693
                } else {
1694
                    null_ = true;
1695
                }
1696

    
1697
                if (me.isLookup == 1 || me.isLookup == 'Y' || me.isLookup == true) {
1698
                    if (rec.LookupGrid == 1) {
1699
                        switch (rec.FormatRef) {
1700
                            case "file":
1701
                                cols_.push({
1702
                                    xtype: 'minovapicturecolumn',
1703
                                    text: rec.HeaderTitle,
1704
                                    dataIndex: rec.FieldName,
1705
                                    width: 100,
1706
                                    //filter: {
1707
                                    //    type: 'image',
1708
                                    //    itemDefaults: {
1709
                                    //        emptyText: 'Search for...'
1710
                                    //    }
1711
                                    //}
1712
                                });
1713
                                break
1714
                            case "date":
1715
                                cols_.push({
1716
                                    xtype: 'minovadatecolumn',
1717
                                    text: rec.HeaderTitle,
1718
                                    dataIndex: rec.FieldName,
1719
                                    width: 100,
1720
                                    filter: {
1721
                                        type: 'date',
1722
                                        itemDefaults: {
1723
                                            emptyText: 'Search for...'
1724
                                        }
1725
                                    }
1726
                                });
1727
                                break
1728
                            case "amount":
1729
                                cols_.push({
1730
                                    xtype: 'minovacurrancycolumn',
1731
                                    text: rec.HeaderTitle,
1732
                                    dataIndex: rec.FieldName,
1733
                                    align: 'right',
1734
                                    width: 300,
1735
                                    filter: {
1736
                                        type: 'number',
1737
                                        itemDefaults: {
1738
                                            emptyText: 'Search for...'
1739
                                        }
1740
                                    }
1741
                                });
1742
                                break
1743
                            case "amountencrypt":
1744
                                cols_.push({
1745
                                    xtype: 'minovaamountcolumn',
1746
                                    text: rec.HeaderTitle,
1747
                                    dataIndex: rec.FieldName,
1748
                                    align: 'right',
1749
                                    width: 300,
1750
                                    filter: {
1751
                                        type: 'string',
1752
                                        itemDefaults: {
1753
                                            emptyText: 'Search for...'
1754
                                        }
1755
                                    }
1756
                                });
1757
                                break
1758
                            case "datetime":
1759
                                cols_.push({
1760
                                    xtype: 'minovadatetimecolumn',
1761
                                    text: rec.HeaderTitle,
1762
                                    dataIndex: rec.FieldName,
1763
                                    width: 140,
1764
                                    filter: {
1765
                                        type: 'string',
1766
                                        itemDefaults: {
1767
                                            emptyText: 'Search for...'
1768
                                        }
1769
                                    }
1770
                                });
1771
                                break
1772
                            default:
1773
                                if (rec.DataRef == 'CREATEBY' || rec.DataRef == 'CHANGEBY') {
1774
                                    cols_.push({
1775
                                        text: rec.HeaderTitle,
1776
                                        dataIndex: rec.FieldName,
1777
                                        width: 100,
1778
                                        filter: {
1779
                                            type: 'string',
1780
                                            itemDefaults: {
1781
                                                emptyText: 'Search for...'
1782
                                            }
1783
                                        }
1784
                                    });
1785
                                } else if (rec.SearchType == '2') {
1786
                                    cols_.push({
1787
                                        xtype: 'minovalookupcolumn',
1788
                                        text: rec.HeaderTitle,
1789
                                        tableName: rec.TableRef,
1790
                                        dataIndex: rec.FieldName,
1791
                                        filter: {
1792
                                            itemDefaults: {
1793
                                                emptyText: 'Search for...'
1794
                                            }
1795
                                        }
1796
                                    });
1797
                                } else if (rec.TableRef != "" && rec.SearchType != '2') {
1798
                                    if (rec.TableRef != null) {
1799
                                        var valueField = null;
1800
                                        var displayValue = null;
1801
                                        Ext.Ajax.request({
1802
                                            async: false,
1803
                                            method: 'POST',
1804
                                            url: '/UserControl/GetStore',
1805
                                            params: {
1806
                                                tableName: 'SDATATABLEFIELD',
1807
                                                param: 'TableName[equal]' + rec.TableRef
1808
                                            },
1809
                                            success: function (response) {
1810
                                                var results = Ext.decode(response.responseText);
1811
                                                data_ = results.data;
1812
                                                if (data_ != undefined) {
1813
                                                    valueField_ = $.grep(data_, function (r) {
1814
                                                        return r.ValueField == '1'
1815
                                                    });
1816
                                                    valueField = valueField_[0].FieldName
1817
                                                    displayValue_ = $.grep(data_, function (r) {
1818
                                                        return r.DisplayValue == '1'
1819
                                                    });
1820
                                                    displayValue = displayValue_[0].FieldName
1821
                                                }
1822
                                            }
1823
                                        });
1824
                                        var store_ = Ext.StoreMgr.lookup('store_' + rec.FieldName);
1825
                                        var count_ = 0;
1826
                                        if (store_) {
1827
                                            count_ = store_.count();
1828
                                        }
1829
                                        if (count_ == 0) {
1830
                                            Ext.create('Ext.data.Store', {
1831
                                                storeId: 'store_' + rec.FieldName,
1832
                                                //autoLoad: true,
1833
                                                proxy: {
1834
                                                    method: 'POST',
1835
                                                    type: 'ajax',
1836
                                                    url: '/UserControl/GetStore',
1837
                                                    extraParams: {
1838
                                                        tableName: rec.TableRef,
1839
                                                        param: rec.ParamCombo
1840
                                                    },
1841
                                                    reader: {
1842
                                                        type: 'json',
1843
                                                        root: 'data',
1844
                                                        totalProperty: 'data[0].TotalCount'
1845
                                                    }
1846
                                                }
1847
                                            })
1848
                                        }
1849
                                        cols_.push({
1850
                                            xtype: 'minovacombocolumn',
1851
                                            text: rec.HeaderTitle,
1852
                                            dataIndex: rec.FieldName,
1853
                                            valueField: valueField,
1854
                                            displayField: displayValue,
1855
                                            store: 'store_' + rec.FieldName,
1856
                                            filter: {
1857
                                                type: 'list',
1858
                                                itemDefaults: {
1859
                                                    emptyText: 'Search for...'
1860
                                                }
1861
                                            }
1862
                                        });
1863
                                    }
1864

    
1865
                                } else {
1866
                                    cols_.push({
1867
                                        text: rec.HeaderTitle,
1868
                                        dataIndex: rec.FieldName,
1869
                                        filter: {
1870
                                            itemDefaults: {
1871
                                                emptyText: 'Search for...'
1872
                                            }
1873
                                        }
1874
                                    });
1875
                                }
1876
                                break
1877
                        }
1878
                    } else {
1879
                        cols_.push({
1880
                            text: rec.HeaderTitle,
1881
                            dataIndex: rec.FieldName,
1882
                            hidden: true,
1883
                            filter: {
1884
                                itemDefaults: {
1885
                                    emptyText: 'Search for...'
1886
                                }
1887
                            }
1888
                        });
1889
                    }
1890

    
1891
                } else {
1892
                    if (rec.GridView == 1) {
1893
                        switch (rec.FormatRef) {
1894
                            case "action":
1895
                                cols_.push({
1896
                                    text: rec.HeaderTitle,
1897
                                    width: 100,
1898
                                    xtype: 'actioncolumn',
1899
                                    tooltip: 'View Data',
1900
                                    name: rec.FieldName,
1901
                                    itemId: me.tableName + rec.FieldName,
1902
                                    align: 'center',
1903
                                    iconCls: 'fa-edit',
1904
                                    renderer: function (value, metadata, record) {
1905
                                        metadata.tdStyle = 'font-family: FontAwesome'
1906
                                    },
1907
                                    handler: function (grid, rowIndex, colIndex, actionItem, event, record, row) {
1908

    
1909
                                        this.fireEvent(me.tableName + rec.FieldName + "onActionClick", record);
1910
                                    }
1911
                                });
1912
                                break
1913
                            case "file":
1914
                                cols_.push({
1915
                                    xtype: 'minovapicturecolumn',
1916
                                    text: rec.HeaderTitle,
1917
                                    dataIndex: rec.FieldName,
1918
                                    width: 100,
1919
                                    //filter: {
1920
                                    //    type: '',
1921
                                    //    itemDefaults: {
1922
                                    //        emptyText: 'Search for...'
1923
                                    //    }
1924
                                    //}
1925
                                });
1926
                                break
1927
                            case "date":
1928
                                cols_.push({
1929
                                    xtype: 'minovadatecolumn',
1930
                                    text: rec.HeaderTitle,
1931
                                    dataIndex: rec.FieldName,
1932
                                    width: 100,
1933
                                    filter: {
1934
                                        type: 'date',
1935
                                        itemDefaults: {
1936
                                            emptyText: 'Search for...'
1937
                                        }
1938
                                    }
1939
                                });
1940
                                break
1941
                            case "amountencrypt":
1942
                                cols_.push({
1943
                                    xtype: 'minovaamountcolumn',
1944
                                    text: rec.HeaderTitle,
1945
                                    dataIndex: rec.FieldName,
1946
                                    align: 'right',
1947
                                    width: 300,
1948
                                    filter: {
1949
                                        type: 'string',
1950
                                        itemDefaults: {
1951
                                            emptyText: 'Search for...'
1952
                                        }
1953
                                    }
1954
                                });
1955
                                break
1956
                            case "amount":
1957
                                cols_.push({
1958
                                    xtype: 'minovacurrancycolumn',
1959
                                    text: rec.HeaderTitle,
1960
                                    dataIndex: rec.FieldName,
1961
                                    align: 'right',
1962
                                    width: 300,
1963
                                    filter: {
1964
                                        type: 'number',
1965
                                        itemDefaults: {
1966
                                            emptyText: 'Search for...'
1967
                                        }
1968
                                    }
1969
                                });
1970
                                break
1971
                            case "datetime":
1972
                                cols_.push({
1973
                                    xtype: 'minovadatetimecolumn',
1974
                                    text: rec.HeaderTitle,
1975
                                    dataIndex: rec.FieldName,
1976
                                    width: 140,
1977
                                    filter: {
1978
                                        type: 'string',
1979
                                        itemDefaults: {
1980
                                            emptyText: 'Search for...'
1981
                                        }
1982
                                    }
1983
                                });
1984
                                break
1985
                            default:
1986
                                if (rec.DataRef == 'CREATEBY' || rec.DataRef == 'CHANGEBY') {
1987
                                    cols_.push({
1988
                                        text: rec.HeaderTitle,
1989
                                        dataIndex: rec.FieldName,
1990
                                        width: 100,
1991
                                        filter: {
1992
                                            type: 'string',
1993
                                            itemDefaults: {
1994
                                                emptyText: 'Search for...'
1995
                                            }
1996
                                        }
1997
                                    });
1998
                                } else if (rec.TableRef != "") {
1999
                                    if (rec.TableRef != null) {
2000
                                        var valueField = null;
2001
                                        var displayValue = null;
2002
                                        Ext.Ajax.request({
2003
                                            async: false,
2004
                                            method: 'POST',
2005
                                            url: '/UserControl/GetStore',
2006
                                            params: {
2007
                                                tableName: 'SDATATABLEFIELD',
2008
                                                param: 'TableName[equal]' + rec.TableRef
2009
                                            },
2010
                                            success: function (response) {
2011
                                                var results = Ext.decode(response.responseText);
2012
                                                data_ = results.data;
2013
                                                //if (data_ != undefined) {
2014
                                                if (data_.length > 0) {
2015
                                                    valueField_ = $.grep(data_, function (r) {
2016
                                                        return r.ValueField == '1'
2017
                                                    });
2018
                                                    valueField = valueField_[0].FieldName
2019
                                                    displayValue_ = $.grep(data_, function (r) {
2020
                                                        return r.DisplayValue == '1'
2021
                                                    });
2022
                                                    displayValue = displayValue_[0].FieldName
2023
                                                } else {
2024
                                                    MinovaMessage('Not Null', 'BSNULLCOMBO', rec.TableRef, 'E');
2025
                                                }
2026
                                            }
2027
                                        });
2028
                                        var store_ = Ext.StoreMgr.lookup('store_' + rec.FieldName);
2029
                                        var count_ = 0;
2030
                                        if (store_) {
2031
                                            count_ = store_.count();
2032
                                        }
2033
                                        if (count_ == 0) {
2034
                                            Ext.create('Ext.data.Store', {
2035
                                                storeId: 'store_' + rec.FieldName,
2036
                                                autoLoad: false,
2037
                                                proxy: {
2038
                                                    method: 'POST',
2039
                                                    type: 'ajax',
2040
                                                    url: '/UserControl/GetStore',
2041
                                                    extraParams: {
2042
                                                        tableName: rec.TableRef,
2043
                                                        param: rec.ParamCombo
2044
                                                    },
2045
                                                    reader: {
2046
                                                        type: 'json',
2047
                                                        root: 'data',
2048
                                                        totalProperty: 'data[0].TotalCount'
2049
                                                    }
2050
                                                }
2051
                                            })
2052
                                        }
2053
                                        cols_.push({
2054
                                            xtype: 'minovacombocolumn',
2055
                                            text: rec.HeaderTitle,
2056
                                            dataIndex: rec.FieldName,
2057
                                            valueField: valueField,
2058
                                            displayField: displayValue,
2059
                                            store: 'store_' + rec.FieldName,
2060
                                            filter: {
2061
                                                type: 'list',
2062
                                                itemDefaults: {
2063
                                                    emptyText: 'Search for...'
2064
                                                }
2065
                                            }
2066
                                        });
2067
                                    }
2068

    
2069
                                } else if (rec.FixedValue != "") {
2070
                                    cols_.push({
2071
                                        xtype: 'minovacombocolumnfixvalue',
2072
                                        text: rec.HeaderTitle,
2073
                                        dataIndex: rec.FieldName,
2074
                                        fixedValue: rec.FixedValue,
2075
                                        filter: {
2076
                                            type: 'list',
2077
                                            itemDefaults: {
2078
                                                emptyText: 'Search for...'
2079
                                            }
2080
                                        }
2081
                                    });
2082
                                } else {
2083
                                    cols_.push({
2084
                                        text: rec.HeaderTitle,
2085
                                        dataIndex: rec.FieldName,
2086
                                        filter: {
2087
                                            itemDefaults: {
2088
                                                emptyText: 'Search for...'
2089
                                            }
2090
                                        }
2091
                                    });
2092
                                }
2093
                                break
2094
                        }
2095
                    } else {
2096
                        cols_.push({
2097
                            text: rec.HeaderTitle,
2098
                            dataIndex: rec.FieldName,
2099
                            hidden: true,
2100
                            filter: {
2101
                                itemDefaults: {
2102
                                    emptyText: 'Search for...'
2103
                                }
2104
                            }
2105
                        });
2106
                    }
2107

    
2108
                }
2109
            });
2110
        };
2111
        var param_ = me.param;
2112
        if (param_ == undefined) {
2113
            param_ = ''
2114
        }
2115
        var jsStoreGrid = new Ext.data.Store({
2116
            storeId: me.storename,
2117
            autoLoad: autoLoad,
2118
            pageSize: me.pagesize,
2119
            proxy: {
2120
                method: 'POST',
2121
                type: 'ajax',
2122
                url: '/UserControl/GetStorePagingAuth',
2123
                extraParams: {
2124
                    tableName: me.tableName,
2125
                    param: param_,
2126
                    menuId: MinovaUtil.GetMenuID()
2127
                },
2128
                reader: {
2129
                    type: 'json',
2130
                    root: 'data',
2131
                    totalProperty: 'totalRecords'
2132
                }
2133
            },
2134
        });
2135
        Ext.applyIf(me, {
2136
            autoScroll: true,
2137
            enableLocking: locking,
2138
            lockedGridConfig: {
2139
                header: false,
2140
                collapsible: true,
2141
                width: widthLock,
2142
                forceFit: locking,
2143
                listeners: {
2144
                    render: function (grid) {
2145
                        var pagingToolbar = grid.child('pagingtoolbar');
2146
                        if (pagingToolbar) {
2147
                            grid.remove(pagingToolbar, true);
2148
                        }
2149
                    }
2150
                }
2151
            },
2152
            listeners: {
2153
                viewready: function () {
2154
                    if (autoLoad == true) {
2155
                        this.getStore().loadPage(1);
2156
                    }
2157
                },
2158
                beforeedit: function () {
2159
                    return false;
2160
                },
2161
            },
2162
            lockedViewConfig: {
2163
                scroll: 'horizontal'
2164
            },
2165
            viewConfig: {
2166
                emptyText: 'No Data Display',
2167
                deferEmptyText: false,
2168
                //Add Nana For Autosize Column Mode
2169
                listeners: {
2170
                    refresh: function (dataview) {
2171
                        Ext.each(dataview.panel.columns, function (column) {
2172
                            //if (column.autoSizeColumn == false)
2173
                            //	column.autoSizeColumn = true;
2174
                            column.autoSize();
2175
                            //dataview.store.reload();
2176
                        })
2177
                    },
2178
                    afterrender: function (dataview) {
2179
                        Ext.defer(function () {
2180
                            dataview.store.reload();
2181
                        }, 2000, this);
2182
                        //dataview.store.reload();
2183
                    }
2184
                },
2185
                render: function (comp) {
2186
                    comp.getStore().reload();					
2187
                }
2188
            },
2189
            //for chekbox
2190
            selModel: {
2191
                //type: 'cellmodel'
2192
            },
2193
            selType: checkSelection,
2194
            columns: cols_,
2195

    
2196
            store: jsStoreGrid,
2197

    
2198
            plugins: [{
2199
                ptype: 'gridfilters'
2200
            }
2201
            ],
2202

    
2203
        });
2204
        me.callParent(arguments);
2205
    }
2206

    
2207
});
2208

    
2209
Ext.define('MinovaUtil.MinovaES.MinovaGrid2', {
2210
    extend: 'Ext.grid.Panel',
2211
    requires: ['Ext.grid.RowNumberer'],
2212
    alias: 'widget.minovagrid2',
2213
    //alias: ['widget.minovagrid2', 'widget.minovagrid'],
2214
    //alias: ['widget.minovagrid2', 'widget.minovagrid'],
2215
    alternateClassName: 'Ext.grid.MinovaGrid',
2216
    //controller:'orm-manage2-controller',
2217
    tableName: undefined,
2218
    isLookup: undefined,
2219
    param: undefined,
2220
    pagesize: undefined,
2221
    storename: undefined,
2222
    layoutType: undefined,
2223
    enableLocking: true,
2224
    autoLoad: undefined,
2225
    multiSelect: undefined,
2226
    getTableName: function () {
2227
        return this.tableName;
2228
    },
2229

    
2230
    initComponent: function () {
2231
        var me = this;
2232
        var cols_ = [];
2233
        var fieldeditor = {};
2234
        var hasil = null;
2235
        var autoLoad = true;
2236
        var LangID = localStorage.LangId;
2237
        var fielGrid = 'rec.GridView == 1';
2238
        var locking = true;
2239
        var checkSelection = '';
2240
        var widthLock = 250;
2241
        if (me.multiSelect) {
2242
            locking = false;
2243
            checkSelection = 'checkboxmodel';
2244
            widthLock = 40;
2245
        }
2246
        //var _url = 'GetAllField';
2247
        if (me.autoLoad == false) {
2248
            autoLoad = false;
2249
        }
2250
        parameter = null;
2251
        if (me.isLookup == 1 || me.isLookup == 'Y' || me.isLookup == true) {
2252
            parameter = "LangID='" + LangID + "',TableName='" + me.tableName + "',LookupGrid='1'";
2253
            fielGrid = 'rec.LookupGrid == 1';
2254
            locking = false;
2255

    
2256
        } else {
2257
            parameter = "LangID='" + LangID + "',TableName='" + me.tableName + "'"
2258
            //autoLoad = false;
2259
            //_url = 'GetAllFieldGridLookUp';
2260
        };
2261

    
2262
        //Ext.Ajax.request({
2263
        //	async : false,
2264
        //	method : 'POST',
2265
        //	url : '/Devt/' + _url + '?tableName=' + me.tableName,
2266
        //	success : function (response) {
2267
        //		var results = Ext.decode(response.responseText);
2268
        //		hasil = results.data;
2269
        //	}
2270
        //});
2271
        //hamid03102016
2272

    
2273
        Ext.Ajax.request({
2274
            async: false,
2275
            method: 'POST',
2276
            url: '/UserControl/GetStore',
2277
            params: {
2278
                tableName: 'PDSBS0007',
2279
                param: parameter
2280
            },
2281
            success: function (response) {
2282
                var results = Ext.decode(response.responseText);
2283
                hasil = results.data;
2284
            }
2285
        });
2286
        //end
2287

    
2288
        if (hasil.length > 0) {
2289

    
2290
            Ext.each(hasil, function (rec) {
2291
                var null_ = null;
2292
                if (rec.IsPrimaryKey == true) {
2293
                    null_ = false;
2294
                }
2295
                if (rec.IsRequired == true) {
2296
                    null_ = false;
2297
                } else {
2298
                    null_ = true;
2299
                }
2300

    
2301
                if (me.isLookup == 1 || me.isLookup == 'Y' || me.isLookup == true) {
2302
                    if (rec.LookupGrid == 1) {
2303
                        switch (rec.FormatRef) {
2304
                            case "file":
2305
                                cols_.push({
2306
                                    xtype: 'minovapicturecolumn',
2307
                                    text: rec.HeaderTitle,
2308
                                    dataIndex: rec.FieldName,
2309
                                    width: 100,
2310
                                    //filter: {
2311
                                    //    type: 'image',
2312
                                    //    itemDefaults: {
2313
                                    //        emptyText: 'Search for...'
2314
                                    //    }
2315
                                    //}
2316
                                });
2317
                                break
2318
                            case "date":
2319
                                cols_.push({
2320
                                    xtype: 'minovadatecolumn',
2321
                                    text: rec.HeaderTitle,
2322
                                    dataIndex: rec.FieldName,
2323
                                    width: 100,
2324
                                    filter: {
2325
                                        type: 'date',
2326
                                        itemDefaults: {
2327
                                            emptyText: 'Search for...'
2328
                                        }
2329
                                    }
2330
                                });
2331
                                break
2332
                            case "amount":
2333
                                cols_.push({
2334
                                    xtype: 'minovacurrancycolumn',
2335
                                    text: rec.HeaderTitle,
2336
                                    dataIndex: rec.FieldName,
2337
                                    align: 'right',
2338
                                    width: 300,
2339
                                    filter: {
2340
                                        type: 'number',
2341
                                        itemDefaults: {
2342
                                            emptyText: 'Search for...'
2343
                                        }
2344
                                    }
2345
                                });
2346
                                break
2347
                            case "amountencrypt":
2348
                                cols_.push({
2349
                                    xtype: 'minovaamountcolumn',
2350
                                    text: rec.HeaderTitle,
2351
                                    dataIndex: rec.FieldName,
2352
                                    align: 'right',
2353
                                    width: 300,
2354
                                    filter: {
2355
                                        type: 'string',
2356
                                        itemDefaults: {
2357
                                            emptyText: 'Search for...'
2358
                                        }
2359
                                    }
2360
                                });
2361
                                break
2362
                            case "datetime":
2363
                                cols_.push({
2364
                                    xtype: 'minovadatetimecolumn',
2365
                                    text: rec.HeaderTitle,
2366
                                    dataIndex: rec.FieldName,
2367
                                    width: 140,
2368
                                    filter: {
2369
                                        type: 'string',
2370
                                        itemDefaults: {
2371
                                            emptyText: 'Search for...'
2372
                                        }
2373
                                    }
2374
                                });
2375
                                break
2376
                            default:
2377
                                if (rec.DataRef == 'CREATEBY' || rec.DataRef == 'CHANGEBY') {
2378
                                    cols_.push({
2379
                                        text: rec.HeaderTitle,
2380
                                        dataIndex: rec.FieldName,
2381
                                        width: 100,
2382
                                        filter: {
2383
                                            type: 'string',
2384
                                            itemDefaults: {
2385
                                                emptyText: 'Search for...'
2386
                                            }
2387
                                        }
2388
                                    });
2389
                                } else if (rec.SearchType == '2') {
2390
                                    cols_.push({
2391
                                        xtype: 'minovalookupcolumn',
2392
                                        text: rec.HeaderTitle,
2393
                                        tableName: rec.TableRef,
2394
                                        dataIndex: rec.FieldName,
2395
                                        filter: {
2396
                                            itemDefaults: {
2397
                                                emptyText: 'Search for...'
2398
                                            }
2399
                                        }
2400
                                    });
2401
                                } else if (rec.TableRef != "" && rec.SearchType != '2') {
2402
                                    if (rec.TableRef != null) {
2403
                                        var valueField = null;
2404
                                        var displayValue = null;
2405
                                        Ext.Ajax.request({
2406
                                            async: false,
2407
                                            method: 'POST',
2408
                                            url: '/UserControl/GetStore',
2409
                                            params: {
2410
                                                tableName: 'SDATATABLEFIELD',
2411
                                                param: 'TableName[equal]' + rec.TableRef
2412
                                            },
2413
                                            success: function (response) {
2414
                                                var results = Ext.decode(response.responseText);
2415
                                                data_ = results.data;
2416
                                                if (data_ != undefined) {
2417
                                                    valueField_ = $.grep(data_, function (r) {
2418
                                                        return r.ValueField == '1'
2419
                                                    });
2420
                                                    valueField = valueField_[0].FieldName
2421
                                                    displayValue_ = $.grep(data_, function (r) {
2422
                                                        return r.DisplayValue == '1'
2423
                                                    });
2424
                                                    displayValue = displayValue_[0].FieldName
2425
                                                }
2426
                                            }
2427
                                        });
2428
                                        var store_ = Ext.StoreMgr.lookup('store_' + rec.FieldName);
2429
                                        var count_ = 0;
2430
                                        if (store_) {
2431
                                            count_ = store_.count();
2432
                                        }
2433
                                        if (count_ == 0) {
2434
                                            Ext.create('Ext.data.Store', {
2435
                                                storeId: 'store_' + rec.FieldName,
2436
                                                //autoLoad: true,
2437
                                                proxy: {
2438
                                                    method: 'POST',
2439
                                                    type: 'ajax',
2440
                                                    url: '/UserControl/GetStore',
2441
                                                    extraParams: {
2442
                                                        tableName: rec.TableRef,
2443
                                                        param: rec.ParamCombo
2444
                                                    },
2445
                                                    reader: {
2446
                                                        type: 'json',
2447
                                                        root: 'data',
2448
                                                        totalProperty: 'data[0].TotalCount'
2449
                                                    }
2450
                                                }
2451
                                            })
2452
                                        }
2453
                                        cols_.push({
2454
                                            xtype: 'minovacombocolumn',
2455
                                            text: rec.HeaderTitle,
2456
                                            dataIndex: rec.FieldName,
2457
                                            valueField: valueField,
2458
                                            displayField: displayValue,
2459
                                            store: 'store_' + rec.FieldName,
2460
                                            filter: {
2461
                                                type: 'list',
2462
                                                itemDefaults: {
2463
                                                    emptyText: 'Search for...'
2464
                                                }
2465
                                            }
2466
                                        });
2467
                                    }
2468

    
2469
                                } else {
2470
                                    cols_.push({
2471
                                        text: rec.HeaderTitle,
2472
                                        dataIndex: rec.FieldName,
2473
                                        filter: {
2474
                                            itemDefaults: {
2475
                                                emptyText: 'Search for...'
2476
                                            }
2477
                                        }
2478
                                    });
2479
                                }
2480
                                break
2481
                        }
2482
                    } else {
2483
                        cols_.push({
2484
                            text: rec.HeaderTitle,
2485
                            dataIndex: rec.FieldName,
2486
                            hidden: true,
2487
                            filter: {
2488
                                itemDefaults: {
2489
                                    emptyText: 'Search for...'
2490
                                }
2491
                            }
2492
                        });
2493
                    }
2494

    
2495
                } else {
2496
                    if (rec.GridView == 1) {
2497
                        switch (rec.FormatRef) {
2498
                            case "action":
2499
                                cols_.push({
2500
                                    text: rec.HeaderTitle,
2501
                                    width: 100,
2502
                                    xtype: 'actioncolumn',
2503
                                    tooltip: 'View Data',
2504
                                    name: rec.FieldName,
2505
                                    itemId: me.tableName + rec.FieldName,
2506
                                    align: 'center',
2507
                                    iconCls: 'fa-edit',
2508
                                    renderer: function (value, metadata, record) {
2509
                                        metadata.tdStyle = 'font-family: FontAwesome'
2510
                                    },
2511
                                    handler: function (grid, rowIndex, colIndex, actionItem, event, record, row) {
2512

    
2513
                                        this.fireEvent(me.tableName + rec.FieldName + "onActionClick", record);
2514
                                    }
2515
                                });
2516
                                break
2517
                            case "file":
2518
                                cols_.push({
2519
                                    xtype: 'minovapicturecolumn',
2520
                                    text: rec.HeaderTitle,
2521
                                    dataIndex: rec.FieldName,
2522
                                    width: 100,
2523
                                    //filter: {
2524
                                    //    type: '',
2525
                                    //    itemDefaults: {
2526
                                    //        emptyText: 'Search for...'
2527
                                    //    }
2528
                                    //}
2529
                                });
2530
                                break
2531
                            case "date":
2532
                                cols_.push({
2533
                                    xtype: 'minovadatecolumn',
2534
                                    text: rec.HeaderTitle,
2535
                                    dataIndex: rec.FieldName,
2536
                                    width: 100,
2537
                                    filter: {
2538
                                        type: 'date',
2539
                                        itemDefaults: {
2540
                                            emptyText: 'Search for...'
2541
                                        }
2542
                                    }
2543
                                });
2544
                                break
2545
                            case "amountencrypt":
2546
                                cols_.push({
2547
                                    xtype: 'minovaamountcolumn',
2548
                                    text: rec.HeaderTitle,
2549
                                    dataIndex: rec.FieldName,
2550
                                    align: 'right',
2551
                                    width: 300,
2552
                                    filter: {
2553
                                        type: 'string',
2554
                                        itemDefaults: {
2555
                                            emptyText: 'Search for...'
2556
                                        }
2557
                                    }
2558
                                });
2559
                                break
2560
                            case "amount":
2561
                                cols_.push({
2562
                                    xtype: 'minovacurrancycolumn',
2563
                                    text: rec.HeaderTitle,
2564
                                    dataIndex: rec.FieldName,
2565
                                    align: 'right',
2566
                                    width: 300,
2567
                                    filter: {
2568
                                        type: 'number',
2569
                                        itemDefaults: {
2570
                                            emptyText: 'Search for...'
2571
                                        }
2572
                                    }
2573
                                });
2574
                                break
2575
                            case "datetime":
2576
                                cols_.push({
2577
                                    xtype: 'minovadatetimecolumn',
2578
                                    text: rec.HeaderTitle,
2579
                                    dataIndex: rec.FieldName,
2580
                                    width: 140,
2581
                                    filter: {
2582
                                        type: 'string',
2583
                                        itemDefaults: {
2584
                                            emptyText: 'Search for...'
2585
                                        }
2586
                                    }
2587
                                });
2588
                                break
2589
                            default:
2590
                                if (rec.DataRef == 'CREATEBY' || rec.DataRef == 'CHANGEBY') {
2591
                                    cols_.push({
2592
                                        text: rec.HeaderTitle,
2593
                                        dataIndex: rec.FieldName,
2594
                                        width: 100,
2595
                                        filter: {
2596
                                            type: 'string',
2597
                                            itemDefaults: {
2598
                                                emptyText: 'Search for...'
2599
                                            }
2600
                                        }
2601
                                    });
2602
                                } else if (rec.TableRef != "") {
2603
                                    if (rec.TableRef != null) {
2604
                                        var valueField = null;
2605
                                        var displayValue = null;
2606
                                        Ext.Ajax.request({
2607
                                            async: false,
2608
                                            method: 'POST',
2609
                                            url: '/UserControl/GetStore',
2610
                                            params: {
2611
                                                tableName: 'SDATATABLEFIELD',
2612
                                                param: 'TableName[equal]' + rec.TableRef
2613
                                            },
2614
                                            success: function (response) {
2615
                                                var results = Ext.decode(response.responseText);
2616
                                                data_ = results.data;
2617
                                                //if (data_ != undefined) {
2618
                                                if (data_.length > 0) {
2619
                                                    valueField_ = $.grep(data_, function (r) {
2620
                                                        return r.ValueField == '1'
2621
                                                    });
2622
                                                    valueField = valueField_[0].FieldName
2623
                                                    displayValue_ = $.grep(data_, function (r) {
2624
                                                        return r.DisplayValue == '1'
2625
                                                    });
2626
                                                    displayValue = displayValue_[0].FieldName
2627
                                                } else {
2628
                                                    MinovaMessage('Not Null', 'BSNULLCOMBO', rec.TableRef, 'E');
2629
                                                }
2630
                                            }
2631
                                        });
2632
                                        var store_ = Ext.StoreMgr.lookup('store_' + rec.FieldName);
2633
                                        var count_ = 0;
2634
                                        if (store_) {
2635
                                            count_ = store_.count();
2636
                                        }
2637
                                        if (count_ == 0) {
2638
                                            Ext.create('Ext.data.Store', {
2639
                                                storeId: 'store_' + rec.FieldName,
2640
                                                autoLoad: false,
2641
                                                proxy: {
2642
                                                    method: 'POST',
2643
                                                    type: 'ajax',
2644
                                                    url: '/UserControl/GetStore',
2645
                                                    extraParams: {
2646
                                                        tableName: rec.TableRef,
2647
                                                        param: rec.ParamCombo
2648
                                                    },
2649
                                                    reader: {
2650
                                                        type: 'json',
2651
                                                        root: 'data',
2652
                                                        totalProperty: 'data[0].TotalCount'
2653
                                                    }
2654
                                                }
2655
                                            })
2656
                                        }
2657
                                        cols_.push({
2658
                                            xtype: 'minovacombocolumn',
2659
                                            text: rec.HeaderTitle,
2660
                                            dataIndex: rec.FieldName,
2661
                                            valueField: valueField,
2662
                                            displayField: displayValue,
2663
                                            store: 'store_' + rec.FieldName,
2664
                                            filter: {
2665
                                                type: 'list',
2666
                                                itemDefaults: {
2667
                                                    emptyText: 'Search for...'
2668
                                                }
2669
                                            }
2670
                                        });
2671
                                    }
2672

    
2673
                                } else if (rec.FixedValue != "") {
2674
                                    cols_.push({
2675
                                        xtype: 'minovacombocolumnfixvalue',
2676
                                        text: rec.HeaderTitle,
2677
                                        dataIndex: rec.FieldName,
2678
                                        fixedValue: rec.FixedValue,
2679
                                        filter: {
2680
                                            type: 'list',
2681
                                            itemDefaults: {
2682
                                                emptyText: 'Search for...'
2683
                                            }
2684
                                        }
2685
                                    });
2686
                                } else {
2687
                                    cols_.push({
2688
                                        text: rec.HeaderTitle,
2689
                                        dataIndex: rec.FieldName,
2690
                                        filter: {
2691
                                            itemDefaults: {
2692
                                                emptyText: 'Search for...'
2693
                                            }
2694
                                        }
2695
                                    });
2696
                                }
2697
                                break
2698
                        }
2699
                    } else {
2700
                        cols_.push({
2701
                            text: rec.HeaderTitle,
2702
                            dataIndex: rec.FieldName,
2703
                            hidden: true,
2704
                            filter: {
2705
                                itemDefaults: {
2706
                                    emptyText: 'Search for...'
2707
                                }
2708
                            }
2709
                        });
2710
                    }
2711

    
2712
                }
2713
            });
2714
        };
2715
        var param_ = me.param;
2716
        if (param_ == undefined) {
2717
            param_ = ''
2718
        }
2719
        var jsStoreGrid = new Ext.data.Store({
2720
            storeId: me.storename,
2721
            autoLoad: autoLoad,
2722
            pageSize: me.pagesize,
2723
            proxy: {
2724
                method: 'POST',
2725
                type: 'ajax',
2726
                url: '/UserControl/GetStorePagingAuth',
2727
                extraParams: {
2728
                    tableName: me.tableName,
2729
                    param: param_,
2730
                    menuId: MinovaUtil.GetMenuID()
2731
                },
2732
                reader: {
2733
                    type: 'json',
2734
                    root: 'data',
2735
                    totalProperty: 'totalRecords'
2736
                }
2737
            },
2738
        });
2739
        Ext.applyIf(me, {
2740
            autoScroll: true,
2741
            enableLocking: locking,
2742
            lockedGridConfig: {
2743
                header: false,
2744
                collapsible: true,
2745
                width: widthLock,
2746
                forceFit: locking,
2747
                listeners: {
2748
                    render: function (grid) {
2749
                        var pagingToolbar = grid.child('pagingtoolbar');
2750
                        if (pagingToolbar) {
2751
                            grid.remove(pagingToolbar, true);
2752
                        }
2753
                    }
2754
                }
2755
            },
2756
            listeners: {
2757
                viewready: function () {
2758
                    if (autoLoad == true) {
2759
                        this.getStore().loadPage(1);
2760
                    }
2761
                },
2762
                beforeedit: function () {
2763
                    return false;
2764
                },
2765
            },
2766
            lockedViewConfig: {
2767
                scroll: 'horizontal'
2768
            },
2769
            viewConfig: {
2770
                emptyText: 'No Data Display',
2771
                deferEmptyText: false,
2772
                //Add Nana For Autosize Column Mode
2773
                listeners: {
2774
                    refresh: function (dataview) {
2775
                        Ext.each(dataview.panel.columns, function (column) {
2776
                            //if (column.autoSizeColumn == false)
2777
                            //	column.autoSizeColumn = true;
2778
                            column.autoSize();
2779
                            //dataview.store.reload();
2780
                        })
2781
                    }
2782
                },
2783
                render: function (comp) {
2784
                    comp.getStore().reload();					
2785
                }
2786
            },
2787
            //for chekbox
2788
            selModel: {
2789
                //type: 'cellmodel'
2790
            },
2791
            selType: checkSelection,
2792
            columns: cols_,
2793

    
2794
            store: jsStoreGrid,
2795

    
2796
            plugins: [{
2797
                ptype: 'gridfilters'
2798
            }
2799
            ],
2800

    
2801
        });
2802
        me.callParent(arguments);
2803
    }
2804

    
2805
});
2806
Ext.define('MinovaUtil.MinovaES.MinovaGrid', {
2807
    extend: 'Ext.grid.Panel',
2808
    requires: ['Ext.grid.RowNumberer'],
2809
    alias: 'widget.minovagrid',
2810
    //alternateClassName : 'Ext.grid.MinovaGrid',
2811
    tableName: undefined,
2812
    isLookup: undefined,
2813
    param: undefined,
2814
    pagesize: undefined,
2815
    storename: undefined,
2816
    layoutType: undefined,
2817
    enableLocking: true,
2818

    
2819
    tbar: [{
2820
        xtype: 'button',
2821
        text: 'Action',
2822
        name: 'actionBtn',
2823
        //scale: 'medium',
2824
        menu: [{
2825
            text: 'Add',
2826
            name: 'Add_',
2827
            action: 'CRUDaddNewRecord',
2828
            style: 'font-family: FontAwesome',
2829
            iconCls: 'fa-plus-circle',
2830
            handler: function () {
2831
                var layout = null;
2832
                var tolbar = this.up();
2833
                var name = '';
2834
                var tableName = tolbar.up().up().up().tableName;
2835
                var mpnl = Ext.ComponentQuery.query('[name=DetailMD]')[0];
2836
                var titleMain = mpnl.getTitle();
2837
                var pnl = Ext.ComponentQuery.query('[name=MinovaMdDetail]')[0];
2838
                if (pnl) {
2839
                    layout = pnl.getLayoutType();
2840
                    pnl.setLastpage('MinovaGridFormGrid' + tableName);
2841
                    pnl.setLastTitle(titleMain);
2842
                    mpnl.setTitle('Add ' + titleMain);
2843
                } else {
2844
                    pnl = Ext.ComponentQuery.query('[name=MinovaORMDetail]')[0];
2845
                    layout = pnl.getLayoutType();
2846
                    pnl.setLastpage('MinovaGridFormGrid' + tableName);
2847
                    pnl.setLastTitle(titleMain);
2848
                    mpnl.setTitle('Add ' + titleMain);
2849
                }
2850
                if (layout == 'L003') {
2851
                    var _grid = "MinovaGridFormGrid" + tableName;
2852
                    var _formDisplay = "MinovaGridFormDisplay" + tableName;
2853
                    var _formEdit = "MinovaGridFormEdit" + tableName;
2854
                    var g = Ext.ComponentQuery.query('[name=' + _grid + ']')[0];
2855
                    var formDisplay = Ext.ComponentQuery.query('[name=' + _formDisplay + ']')[0];
2856
                    var formEdit = Ext.ComponentQuery.query('[name=' + _formEdit + ']')[0];
2857
                    g.setHidden(true);
2858
                    formDisplay.setHidden(true);
2859
                    formEdit.reset();
2860
                    formEdit.setActionSubmit(0)
2861
                    formEdit.setSubmitProc(true)
2862
                    formEdit.setHidden(false);
2863
                    var heigh = pnl.getLastheightform();
2864
                    var pDetail = Ext.ComponentQuery.query('[name=PanelMdDetail]')[0]
2865
                    if (pDetail) {
2866
                        // pDetail.setHeight(heigh + 100);
2867
                    } else {
2868
                        pDetail = Ext.ComponentQuery.query('[name=PanelOrmMdDetail]')[0];
2869
                        var mainPnl_ = Ext.ComponentQuery.query('[name=MinovaORMDetail]')[0]
2870
                        var mainPnl = mainPnl_.getHeight();
2871
                        //pDetail.setHeight(mainPnl + 100);
2872

    
2873
                    }
2874

    
2875
                    var emp = formEdit.getForm().findField("EmployeeID");
2876
                    if (emp) {
2877
                        emp.setValue(getParam("EmployeeID"))
2878
                        emp.setHidden(true);
2879
                    }
2880

    
2881
                } else {
2882
                    var _grid = "MinovaGridFormGrid" + tableName;
2883
                    var _formDisplay = "MinovaGridFormDisplay" + tableName;
2884
                    var _formEdit = "MinovaGridFormEdit" + tableName;
2885
                    var g = Ext.ComponentQuery.query('[name=' + _grid + ']')[0];
2886
                    var formDisplay = Ext.ComponentQuery.query('[name=' + _formDisplay + ']')[0];
2887
                    var formEdit = Ext.ComponentQuery.query('[name=' + _formEdit + ']')[0];
2888
                    formEdit.setActionSubmit(0)
2889
                    formDisplay.setHidden(true);
2890
                    formDisplay.setTitle("Add");
2891

    
2892
                    formEdit.setTitle("Add - " + titleMain);
2893
                    formEdit.reset();
2894
                    formEdit.setSubmitProc(true)
2895
                    formEdit.setHidden(false);
2896
                    var emp = formEdit.getForm().findField("EmployeeID");
2897
                    if (emp) {
2898
                        emp.setValue(Ext.ComponentQuery.query('[name=EmployeeID]')[0].getValue())
2899
                        emp.setHidden(true);
2900
                    }
2901

    
2902
                }
2903
            }
2904
        }, {
2905
            text: 'Copy',
2906
            name: 'Copy_',
2907
            iconCls: 'fa-copy',
2908
            style: 'font-family: FontAwesome',
2909
            handler: function () {
2910
                var layout = null;
2911
                var tolbar = this.up();
2912
                var name = '';
2913
                var tableName = tolbar.up().up().up().tableName;
2914
                var mpnl = Ext.ComponentQuery.query('[name=DetailMD]')[0];
2915
                var titleMain = mpnl.getTitle();
2916
                var pnl = Ext.ComponentQuery.query('[name=MinovaMdDetail]')[0];
2917

    
2918
                if (pnl) {
2919
                    layout = pnl.getLayoutType();
2920
                    pnl.setLastpage('MinovaGridFormGrid' + tableName);
2921
                    pnl.setLastTitle(titleMain);
2922
                    mpnl.setTitle('Copy ' + titleMain);
2923
                } else {
2924
                    pnl = Ext.ComponentQuery.query('[name=MinovaORMDetail]')[0];
2925
                    layout = pnl.getLayoutType();
2926
                    pnl.setLastpage('MinovaGridFormGrid' + tableName);
2927
                    pnl.setLastTitle(titleMain);
2928
                    mpnl.setTitle('Copy ' + titleMain);
2929
                }
2930
                if (layout == 'L003') {
2931
                    var _grid = "MinovaGridFormGrid" + tableName;
2932
                    var _formDisplay = "MinovaGridFormDisplay" + tableName;
2933
                    var _formEdit = "MinovaGridFormEdit" + tableName;
2934
                    var g = Ext.ComponentQuery.query('[name=' + _grid + ']')[0];
2935
                    var formDisplay = Ext.ComponentQuery.query('[name=' + _formDisplay + ']')[0];
2936
                    var formEdit = Ext.ComponentQuery.query('[name=' + _formEdit + ']')[0];
2937
                    g.setHidden(true);
2938
                    formDisplay.setHidden(true);
2939
                    formEdit.reset();
2940
                    formEdit.setActionSubmit(0)
2941
                    formEdit.setSubmitProc(true)
2942
                    formEdit.setHidden(false);
2943
                    var heigh = pnl.getLastheightform();
2944
                    var pDetail = Ext.ComponentQuery.query('[name=PanelMdDetail]')[0]
2945
                    if (pDetail) {
2946
                        //pDetail.setHeight(heigh + 100);
2947
                    } else {
2948
                        pDetail = Ext.ComponentQuery.query('[name=PanelOrmMdDetail]')[0];
2949
                        var mainPnl_ = Ext.ComponentQuery.query('[name=MinovaORMDetail]')[0]
2950
                        var mainPnl = mainPnl_.getHeight();
2951
                        //pDetail.setHeight(mainPnl + 100);
2952

    
2953
                    }
2954
                    Ext.ComponentQuery.query('[name=MinovaORMDetail]')[0]
2955

    
2956
                    var emp = formEdit.getForm().findField("EmployeeID");
2957
                    if (emp) {
2958
                        emp.setValue(getParam("EmployeeID"))
2959
                        emp.setHidden(true);
2960
                    }
2961
                    var selection = tolbar.up().up().up().getView().getSelectionModel().getSelection()[0];
2962
                    if (selection) {
2963
                        formDisplay.getForm().setValues(selection.data);
2964
                        formEdit.getForm().setValues(selection.data);
2965
                    }
2966

    
2967
                } else {
2968
                    var _grid = "MinovaGridFormGrid" + tableName;
2969
                    var _formDisplay = "MinovaGridFormDisplay" + tableName;
2970
                    var _formEdit = "MinovaGridFormEdit" + tableName;
2971
                    var g = Ext.ComponentQuery.query('[name=' + _grid + ']')[0];
2972
                    var formDisplay = Ext.ComponentQuery.query('[name=' + _formDisplay + ']')[0];
2973
                    var formEdit = Ext.ComponentQuery.query('[name=' + _formEdit + ']')[0];
2974
                    formEdit.setActionSubmit(0)
2975
                    formDisplay.setHidden(true);
2976
                    formDisplay.setTitle("Add");
2977

    
2978
                    formEdit.setTitle("Copy - " + titleMain);
2979
                    formEdit.reset();
2980
                    formEdit.setSubmitProc(true)
2981
                    formEdit.setHidden(false);
2982
                    var emp = formEdit.getForm().findField("EmployeeID");
2983
                    if (emp) {
2984
                        emp.setValue(Ext.ComponentQuery.query('[name=EmployeeID]')[0].getValue())
2985
                        emp.setHidden(true);
2986
                    }
2987
                    var selection = tolbar.up().up().up().getView().getSelectionModel().getSelection()[0];
2988
                    if (selection) {
2989
                        formDisplay.getForm().setValues(selection.data);
2990
                        formEdit.getForm().setValues(selection.data);
2991
                        formEdit.setSubmitProc(true);
2992
                        formEdit.setActionSubmit(0);
2993
                    }
2994

    
2995
                }
2996
            }
2997
        }, {
2998
            text: 'Edit',
2999
            name: 'Edit_',
3000
            iconCls: 'fa-edit',
3001
            style: 'font-family: FontAwesome',
3002
            handler: function () {
3003
                var layout = null;
3004
                var tolbar = this.up();
3005
                var name = '';
3006
                var tableName = tolbar.up().up().up().tableName;
3007

    
3008
                var pnl = Ext.ComponentQuery.query('[name=MinovaMdDetail]')[0];
3009
                if (pnl) {
3010
                    layout = pnl.getLayoutType();
3011
                    pnl.setLastpage('MinovaGridFormGrid' + tableName);
3012

    
3013
                } else {
3014
                    pnl = Ext.ComponentQuery.query('[name=MinovaORMDetail]')[0];
3015
                    layout = pnl.getLayoutType();
3016
                    pnl.setLastpage('MinovaGridFormGrid' + tableName);
3017
                }
3018

    
3019
                if (layout == 'L003') {
3020
                    var _grid = "MinovaGridFormGrid" + tableName;
3021
                    var _formDisplay = "MinovaGridFormDisplay" + tableName;
3022
                    var _formEdit = "MinovaGridFormEdit" + tableName;
3023
                    var g = Ext.ComponentQuery.query('[name=' + _grid + ']')[0];
3024
                    var formDisplay = Ext.ComponentQuery.query('[name=' + _formDisplay + ']')[0];
3025
                    var formEdit = Ext.ComponentQuery.query('[name=' + _formEdit + ']')[0];
3026

    
3027
                    var selection = tolbar.up().up().up().getView().getSelectionModel().getSelection()[0];
3028
                    if (selection) {
3029
                        formDisplay.getForm().setValues(selection.data);
3030
                        formEdit.getForm().setValues(selection.data);
3031
                        formDisplay.setHidden(true);
3032
                        formEdit.setSubmitProc(true);
3033
                        formEdit.setActionSubmit(1);
3034
                        formEdit.setHidden(false);
3035
                        formEdit.setHidden(false);
3036
                        g.setHidden(true);
3037
                        var heigh = pnl.getLastheightform();
3038
                        var pDetail = Ext.ComponentQuery.query('[name=PanelMdDetail]')[0]
3039
                        if (pDetail) {
3040
                            pDetail.setHeight(heigh + 100);
3041
                        } else {
3042
                            pDetail = Ext.ComponentQuery.query('[name=PanelOrmMdDetail]')[0];
3043
                            var mainPnl_ = Ext.ComponentQuery.query('[name=MinovaORMDetail]')[0]
3044
                            var mainPnl = mainPnl_.getHeight();
3045
                            //pDetail.setHeight(mainPnl + 100);
3046

    
3047
                        }
3048

    
3049
                        var p = Ext.ComponentQuery.query('[name=DetailMD]')[0];
3050
                        if (p) {
3051
                            var lastTitile = p.getTitle();
3052
                            pnl.setLastTitle(lastTitile);
3053
                            p.setTitle('Edit - ' + lastTitile)
3054

    
3055
                        }
3056
                    }
3057
                } else {
3058
                    var _grid = "MinovaGridFormGrid" + tableName;
3059
                    var _formDisplay = "MinovaGridFormDisplay" + tableName;
3060
                    var _formEdit = "MinovaGridFormEdit" + tableName;
3061
                    var g = Ext.ComponentQuery.query('[name=' + _grid + ']')[0];
3062
                    var formDisplay = Ext.ComponentQuery.query('[name=' + _formDisplay + ']')[0];
3063
                    var formEdit = Ext.ComponentQuery.query('[name=' + _formEdit + ']')[0];
3064

    
3065
                    var selection = tolbar.up().up().up().getView().getSelectionModel().getSelection()[0];
3066
                    if (selection) {
3067
                        formDisplay.getForm().setValues(selection.data);
3068
                        formEdit.getForm().setValues(selection.data);
3069
                        formDisplay.setTitle("Edit");
3070
                        formEdit.setTitle("Edit");
3071
                        if (layout == 'L003') {
3072
                            g.setHidden(true);
3073
                        }
3074

    
3075
                        formDisplay.setHidden(true);
3076
                        formEdit.setActionSubmit(1)
3077
                        formEdit.setSubmitProc(true)
3078
                        formEdit.setHidden(false);
3079

    
3080
                        var mpnl = Ext.ComponentQuery.query('[name=DetailMD]')[0]
3081
                        var lastTitile = mpnl.getTitle();
3082
                        formEdit.setTitle('Edit - ' + lastTitile);
3083
                        //mpnl.setTitle('Edit ' + lastTitile);
3084
                    }
3085
                }
3086
            }
3087
        }, {
3088
            text: 'Delete',
3089
            name: 'Delete_',
3090
            iconCls: 'fa-trash-o',
3091
            style: 'font-family: FontAwesome',
3092
        }
3093
        ]
3094
    }, {
3095
        xtype: 'tbfill'
3096
    }, {
3097
        text: 'Clear Filters',
3098
        tooltip: 'Clear all filters',
3099
        name: 'clearbtn',
3100
        handler: function () {
3101
            var tolbar = this.up()
3102
            var grid_ = tolbar.up()
3103
            grid_.filters.clearFilters()
3104
        }
3105
    }, ],
3106

    
3107
    getTableName: function () {
3108
        return this.tableName;
3109
    },
3110

    
3111
    initComponent: function () {
3112
        var me = this;
3113
        var cols_ = [];
3114
        var fieldeditor = {};
3115
        var hasil = null;
3116
        var autoLoad = true;
3117
        var LangID = MinovaUtil.GetLangID();
3118
        //var _url = 'GetAllField';
3119

    
3120
        //if (me.isLookup == 1 || me.isLookup == 'Y' || me.isLookup == true) {
3121
        //	autoLoad = false;
3122
        //    _url = 'GetAllFieldGridLookUp';
3123

    
3124
        //};
3125
        //Ext.Ajax.request({
3126
        //	async : false,
3127
        //	method : 'POST',
3128
        //	url : '/Devt/' + _url + '?tableName=' + me.tableName,
3129
        //	success : function (response) {
3130
        //		var results = Ext.decode(response.responseText);
3131
        //		hasil = results.data;
3132
        //	}
3133
        //});
3134
        //hamid03102016
3135
        //if (me.isLookup == 1 || isLookup == true || isLookup == 'Y') {
3136
        parameter = null;
3137
        if (me.isLookup == true || isLookup == 1 || isLookup == 'Y') {
3138
            parameter = "LangID='" + LangID + "',TableName='" + me.tableName + "',LookupGrid='1'"
3139
        } else {
3140
            parameter = "LangID='" + LangID + "',TableName='" + me.tableName + "'"
3141
        }
3142
        Ext.Ajax.request({
3143
            async: false,
3144
            method: 'POST',
3145
            url: '/UserControl/GetStore',
3146
            params: {
3147
                tableName: 'PDSBS0007',
3148
                param: parameter
3149
            },
3150
            success: function (response) {
3151
                var results = Ext.decode(response.responseText);
3152
                hasil = results.data;
3153
            }
3154
        });
3155
        //end
3156
        if (hasil.length > 0) {
3157
            Ext.each(hasil, function (rec) {
3158
                var null_ = null;
3159
                if (rec.IsPrimaryKey == true) {
3160
                    null_ = false;
3161
                }
3162
                if (rec.IsRequired == true) {
3163
                    null_ = false;
3164
                } else {
3165
                    null_ = true;
3166
                }
3167
                if (rec.GridView == 1) {
3168
                    switch (rec.FormatRef) {
3169
                        case "date":
3170
                            cols_.push({
3171
                                xtype: 'minovadatecolumn',
3172
                                text: rec.HeaderTitle,
3173
                                dataIndex: rec.FieldName,
3174
                                width: 100,
3175
                                filter: {
3176
                                    type: 'date',
3177
                                    itemDefaults: {
3178
                                        emptyText: 'Search for...'
3179
                                    }
3180
                                }
3181
                            });
3182
                            break
3183
                        case "amountencrypt":
3184
                            cols_.push({
3185
                                xtype: 'minovaamountcolumn',
3186
                                text: rec.HeaderTitle,
3187
                                dataIndex: rec.FieldName,
3188
                                align: 'right',
3189
                                width: 100,
3190
                                filter: {
3191
                                    type: 'string',
3192
                                    itemDefaults: {
3193
                                        emptyText: 'Search for...'
3194
                                    }
3195
                                }
3196
                            });
3197
                            break
3198
                        case "amount":
3199
                            cols_.push({
3200
                                xtype: 'minovacurrancycolumn',
3201
                                text: rec.HeaderTitle,
3202
                                dataIndex: rec.FieldName,
3203
                                align: 'right',
3204
                                width: 100,
3205
                                filter: {
3206
                                    type: 'number',
3207
                                    itemDefaults: {
3208
                                        emptyText: 'Search for...'
3209
                                    }
3210
                                }
3211
                            });
3212
                            break
3213
                        case "datetime":
3214
                            cols_.push({
3215
                                xtype: 'minovadatetimecolumn',
3216
                                text: rec.HeaderTitle,
3217
                                dataIndex: rec.FieldName,
3218
                                width: 140,
3219
                                filter: {
3220
                                    type: 'string',
3221
                                    itemDefaults: {
3222
                                        emptyText: 'Search for...'
3223
                                    }
3224
                                }
3225
                            });
3226
                            break
3227
                        default:
3228
                            if (rec.DataRef == 'CREATEBY' || rec.DataRef == 'CHANGEBY') {
3229
                                cols_.push({
3230
                                    text: rec.HeaderTitle,
3231
                                    dataIndex: rec.FieldName,
3232
                                    width: 100,
3233
                                    filter: {
3234
                                        type: 'string',
3235
                                        itemDefaults: {
3236
                                            emptyText: 'Search for...'
3237
                                        }
3238
                                    }
3239
                                });
3240
                            } else if (rec.SearchType == '2') {
3241
                                cols_.push({
3242
                                    xtype: 'minovalookupcolumn',
3243
                                    text: rec.HeaderTitle,
3244
                                    tableName: rec.TableRef,
3245
                                    dataIndex: rec.FieldName,
3246
                                    filter: {
3247
                                        itemDefaults: {
3248
                                            emptyText: 'Search for...'
3249
                                        }
3250
                                    }
3251
                                });
3252
                            } else if (rec.TableRef != "") {
3253
                                if (rec.TableRef != null) {
3254
                                    var valueField = null;
3255
                                    Ext.Ajax.request({
3256
                                        async: false,
3257
                                        method: 'POST',
3258
                                        url: '/UserControl/GetStore',
3259
                                        params: {
3260
                                            tableName: 'SDATATABLEFIELD',
3261
                                            param: 'ValueField[equal]1,TableName[equal]' + rec.TableRef
3262
                                        },
3263
                                        success: function (response) {
3264
                                            var results = Ext.decode(response.responseText);
3265
                                            data_ = results.data[0];
3266
                                            if (data_ != undefined) {
3267
                                                valueField = data_.FieldName;
3268
                                            }
3269
                                        }
3270
                                    });
3271

    
3272
                                    displayValue = null;
3273
                                    Ext.Ajax.request({
3274
                                        async: false,
3275
                                        method: 'POST',
3276
                                        url: '/UserControl/GetStore',
3277
                                        params: {
3278
                                            tableName: 'SDATATABLEFIELD',
3279
                                            param: 'DisplayValue[equal]1,TableName[equal]' + rec.TableRef
3280
                                        },
3281
                                        success: function (response) {
3282
                                            var results = Ext.decode(response.responseText);
3283
                                            data_ = results.data[0];
3284
                                            if (data_ != undefined) {
3285
                                                displayValue = data_.FieldName;
3286
                                                //console.log(data_)
3287
                                            }
3288
                                        }
3289
                                    });
3290
                                    var store_ = Ext.StoreMgr.lookup('store_' + rec.FieldName);
3291
                                    var count_ = 0;
3292
                                    if (store_) {
3293
                                        count_ = store_.count();
3294
                                    }
3295
                                    if (count_ == 0) {
3296
                                        Ext.create('Ext.data.Store', {
3297
                                            storeId: 'store_' + rec.FieldName,
3298
                                            autoLoad: true,
3299
                                            proxy: {
3300
                                                method: 'POST',
3301
                                                type: 'ajax',
3302
                                                url: '/UserControl/GetStore',
3303
                                                extraParams: {
3304
                                                    tableName: rec.TableRef,
3305
                                                    param: rec.ParamCombo
3306
                                                },
3307
                                                reader: {
3308
                                                    type: 'json',
3309
                                                    root: 'data',
3310
                                                    totalProperty: 'data[0].TotalCount'
3311
                                                }
3312
                                            }
3313
                                        })
3314
                                    }
3315
                                    cols_.push({
3316
                                        xtype: 'minovacombocolumn',
3317
                                        text: rec.HeaderTitle,
3318
                                        dataIndex: rec.FieldName,
3319
                                        valueField: valueField,
3320
                                        displayField: displayValue,
3321
                                        store: 'store_' + rec.FieldName,
3322
                                        filter: {
3323
                                            type: 'list',
3324
                                            itemDefaults: {
3325
                                                emptyText: 'Search for...'
3326
                                            }
3327
                                        }
3328
                                    });
3329
                                }
3330

    
3331
                            } else {
3332
                                cols_.push({
3333
                                    text: rec.HeaderTitle,
3334
                                    dataIndex: rec.FieldName,
3335
                                    filter: {
3336
                                        itemDefaults: {
3337
                                            emptyText: 'Search for...'
3338
                                        }
3339
                                    }
3340
                                });
3341
                            }
3342
                            break
3343
                    }
3344
                } else {
3345
                    cols_.push({
3346
                        text: rec.HeaderTitle,
3347
                        dataIndex: rec.FieldName,
3348
                        hidden: true,
3349
                        filter: {
3350
                            itemDefaults: {
3351
                                emptyText: 'Search for...'
3352
                            }
3353
                        }
3354
                    });
3355
                }
3356
            });
3357
        };
3358
        var param_ = me.param;
3359
        if (param_ == undefined) {
3360
            param_ = ''
3361
        }
3362
        var jsStoreGrid = new Ext.data.Store({
3363
            storeId: me.storename,
3364
            autoLoad: autoLoad,
3365
            pageSize: me.pagesize,
3366
            proxy: {
3367
                method: 'POST',
3368
                type: 'ajax',
3369
                url: '/UserControl/GetStorePaging',
3370
                extraParams: {
3371
                    tableName: me.tableName,
3372
                    param: param_
3373
                },
3374
                reader: {
3375
                    type: 'json',
3376
                    root: 'data',
3377
                    totalProperty: 'totalRecords'
3378
                }
3379
            }
3380
        });
3381
        Ext.applyIf(me, {
3382
            autoScroll: true,
3383
            enableLocking: true,
3384
            lockedGridConfig: {
3385
                header: false,
3386
                collapsible: true,
3387
                width: 250,
3388
                forceFit: true,
3389
                listeners: {
3390
                    render: function (grid) {
3391
                        var pagingToolbar = grid.child('pagingtoolbar');
3392
                        if (pagingToolbar) {
3393
                            grid.remove(pagingToolbar, true);
3394
                        }
3395
                    }
3396
                }
3397
            },
3398
            listeners: {
3399
                viewready: function () {
3400
                    if (autoLoad == true) {
3401
                        this.getStore().loadPage(1);
3402
                    }
3403

    
3404
                },
3405
                beforeedit: function () {
3406
                    return false;
3407
                }
3408
            },
3409
            lockedViewConfig: {
3410
                scroll: 'horizontal'
3411
            },
3412
            viewConfig: {
3413
                emptyText: 'No Data Display',
3414
                deferEmptyText: false,
3415
                //add Nana for Autosize Column Mode
3416
                listeners: {
3417
                    refresh: function (dataview) {
3418
                        Ext.each(dataview.panel.columns, function (column) {
3419
                            if (column.autoSizeColumn == false)
3420
                                column.autoSizeColumn = true;
3421
                            column.autoSize();
3422
                        })
3423
                    }
3424
                }
3425
            },
3426
            columns: cols_,
3427

    
3428
            store: jsStoreGrid,
3429

    
3430
            plugins: [{
3431
                ptype: 'gridfilters'
3432
            }, {
3433
                ptype: 'rowediting',
3434
                clicksToEdit: 2,
3435
                listeners: {
3436
                    edit: function (editor, context, eOpts) {}
3437
                }
3438
            }, ]
3439
        });
3440
        me.callParent(arguments);
3441
    }
3442

    
3443
});
3444
/*MinovaGrid Report Generator*/
3445
Ext.define('MinovaUtil.MinovaES.MinovaRptGeneratorGrid', {
3446
    extend: 'Ext.grid.Panel',
3447
    requires: ['Ext.grid.RowNumberer', 'Ext.grid.feature.Grouping'],
3448
    alias: 'widget.minovareportgeneratorgrid',
3449
    storeOutput: undefined,
3450
    storeName: undefined,
3451
    filter: undefined,
3452
    tableName: undefined,
3453
    pagesize: undefined,
3454
    autoLoad: undefined,
3455
    initComponent: function () {
3456
        var me = this;
3457
        var store = me.storeOutput;
3458
        var cols = [];
3459
        var groupField = '';
3460
        var autoLoad = true;
3461
        if (me.autoLoad == false) {
3462
            autoLoad = false;
3463
        }
3464
        if (store.length > 0) {
3465
            Ext.each(store, function (rec) {
3466
                var isHide = false;
3467
                if (rec.IsGrouping == "YES") {
3468
                    groupField = rec.FieldName;
3469
                    isHide = true;
3470
                }
3471
                var format = rec.FormatRef;
3472
                if (format != null && format != undefined)
3473
                    format = format.toLowerCase();
3474
                switch (format) {
3475
                    case "file":
3476
                        cols.push({
3477
                            xtype: 'minovapicturecolumn',
3478
                            text: rec.HeaderTitle,
3479
                            dataIndex: rec.FieldName,
3480
                            hidden: isHide,
3481
                            width: 100
3482
                        });
3483
                        break
3484
                    case "date":
3485
                        cols.push({
3486
                            xtype: 'minovadatecolumn',
3487
                            text: rec.HeaderTitle,
3488
                            dataIndex: rec.FieldName,
3489
                            hidden: isHide,
3490
                            width: 100
3491
                        });
3492
                        break
3493
                    case "amount":
3494
                        cols.push({
3495
                            xtype: 'minovacurrancycolumn',
3496
                            text: rec.HeaderTitle,
3497
                            align: 'right',
3498
                            dataIndex: rec.FieldName,
3499
                            width: 150,
3500
                            hidden: isHide,
3501
                            summaryType: rec.Aggregator,
3502
                            summaryRenderer: function (value) {
3503
                                return Ext.util.Format.number(value, '0,000.00');
3504
                            }
3505
                        });
3506
                        break
3507
                    case "amountencrypt":
3508
                        cols.push({
3509
                            xtype: 'minovaamountcolumn',
3510
                            align: 'right',
3511
                            text: rec.HeaderTitle,
3512
                            dataIndex: rec.FieldName,
3513
                            width: 150,
3514
                            hidden: isHide,
3515
                            summaryType: rec.Aggregator,
3516
                            summaryRenderer: function (value) {
3517
                                if (rec.Aggregator == "sum") {
3518
                                    var str = Ext.StoreManager.lookup("store" + me.tableName);
3519
                                    var records = str.data.items;
3520
                                    var total = 0,
3521
                                    len = records.length;
3522
                                    if (len > 0) {
3523
                                        for (var i = 0; i < len; ++i) {
3524
                                            var nilai = records[i].get(rec.FieldName);
3525
                                            Ext.Ajax.request({
3526
                                                async: false,
3527
                                                method: 'POST',
3528
                                                url: '/Devt/DecryptData',
3529
                                                params: {
3530
                                                    dt: nilai
3531
                                                },
3532
                                                success: function (response) {
3533
                                                    var results = Ext.decode(response.responseText);
3534
                                                    nilai = results.data;
3535
                                                    total += parseFloat(nilai);
3536
                                                }
3537
                                            });
3538
                                        }
3539
                                        Ext.util.Format.thousandSeparator = ".";
3540
                                        return Ext.util.Format.number(total, '0,000');
3541
                                    }
3542
                                    return 0;
3543
                                } else if (rec.Aggregator == "average") {
3544
                                    var str = Ext.StoreManager.lookup("store" + me.tableName);
3545
                                    var records = str.data.items;
3546
                                    var len = records.length,
3547
                                    sum = 0;
3548
                                    if (len > 0) {
3549
                                        for (var i = 0; i < len; ++i) {
3550
                                            var nilai = records[i].get(rec.FieldName);
3551
                                            Ext.Ajax.request({
3552
                                                async: false,
3553
                                                method: 'POST',
3554
                                                url: '/Devt/DecryptData',
3555
                                                params: {
3556
                                                    dt: nilai
3557
                                                },
3558
                                                success: function (response) {
3559
                                                    var results = Ext.decode(response.responseText);
3560
                                                    nilai = results.data;
3561
                                                    sum += parseFloat(nilai);
3562
                                                }
3563
                                            });
3564
                                        }
3565
                                        var rs = sum / len;
3566
                                        Ext.util.Format.thousandSeparator = ".";
3567
                                        return Ext.util.Format.number(rs, '0,000');
3568
                                    }
3569
                                    return 0;
3570
                                } else {
3571
                                    return value;
3572
                                }
3573
                            }
3574
                        });
3575
                        break
3576
                    case "datetime":
3577
                        cols.push({
3578
                            xtype: 'minovadatetimecolumn',
3579
                            text: rec.HeaderTitle,
3580
                            dataIndex: rec.FieldName,
3581
                            width: 150,
3582
                            hidden: isHide
3583
                        });
3584
                        break
3585
                    default:
3586
                        if (rec.TableRef != "" && rec.TableRef != null) {
3587
                            var valueField = null;
3588
                            var displayValue = null;
3589
                            Ext.Ajax.request({
3590
                                async: false,
3591
                                method: 'POST',
3592
                                url: '/UserControl/GetStore',
3593
                                params: {
3594
                                    tableName: 'SDATATABLEFIELD',
3595
                                    param: 'TableName[equal]' + rec.TableRef
3596
                                },
3597
                                success: function (response) {
3598
                                    var results = Ext.decode(response.responseText);
3599
                                    data_ = results.data;
3600
                                    if (data_.length > 0) {
3601
                                        valueField_ = $.grep(data_, function (r) {
3602
                                            return r.ValueField == '1'
3603
                                        });
3604
                                        valueField = valueField_[0].FieldName
3605
                                        displayValue_ = $.grep(data_, function (r) {
3606
                                            return r.DisplayValue == '1'
3607
                                        });
3608
                                        displayValue = displayValue_[0].FieldName
3609
                                    } else {
3610
                                        MinovaMessage('Not Null', 'BSNULLCOMBO', rec.TableRef, 'E');
3611
                                    }
3612
                                }
3613
                            });
3614
                            var store_ = Ext.StoreMgr.lookup('store_' + rec.FieldName);
3615
                            var count_ = 0;
3616
                            if (store_) {
3617
                                count_ = store_.count();
3618
                            }
3619
                            if (count_ == 0) {
3620
                                Ext.create('Ext.data.Store', {
3621
                                    storeId: 'store_' + rec.FieldName,
3622
                                    autoLoad: false,
3623
                                    proxy: {
3624
                                        method: 'POST',
3625
                                        type: 'ajax',
3626
                                        url: '/UserControl/GetStore',
3627
                                        extraParams: {
3628
                                            tableName: rec.TableRef,
3629
                                            param: ""
3630
                                        },
3631
                                        reader: {
3632
                                            type: 'json',
3633
                                            root: 'data',
3634
                                            totalProperty: 'data[0].TotalCount'
3635
                                        }
3636
                                    }
3637
                                })
3638
                            }
3639
                            Ext.StoreMgr.lookup('store_' + rec.FieldName).load();
3640
                            var stror = Ext.StoreMgr.lookup('store_' + rec.FieldName);
3641
                            cols.push({
3642
                                xtype: 'minovacombocolumn',
3643
                                text: rec.HeaderTitle,
3644
                                dataIndex: rec.FieldName,
3645
                                valueField: valueField,
3646
                                displayField: displayValue,
3647
                                store: 'store_' + rec.FieldName,
3648
                                width: 200,
3649
                                hidden: isHide,
3650
                                renderer: function (val) {
3651
                                    var stor = stror;
3652
                                    if (stor.getCount() === 0) {}
3653
                                    var index = stor.find(valueField, val);
3654
                                    if (index != -1) {
3655
                                        var rec = stor.getAt(index);
3656
                                        return val + ' - ' + rec.get(displayValue);
3657
                                    } else {
3658
                                        return val;
3659
                                    }
3660
                                }
3661
                            });
3662
                        } else if (rec.FixedValue != "" && rec.FixedValue != null) {
3663
                            cols.push({
3664
                                xtype: 'minovacombocolumnfixvalue',
3665
                                text: rec.HeaderTitle,
3666
                                dataIndex: rec.FieldName,
3667
                                fixedValue: rec.FixedValue,
3668
                                width: 100,
3669
                                hidden: isHide
3670
                            });
3671
                        } else {
3672
                            if (rec.DataType == "0") {
3673
                                cols.push({
3674
                                    text: rec.HeaderTitle,
3675
                                    dataIndex: rec.FieldName,
3676
                                    width: 150,
3677
                                    hidden: isHide
3678
                                });
3679
                            } else {
3680
                                cols.push({
3681
                                    text: rec.HeaderTitle,
3682
                                    dataIndex: rec.FieldName,
3683
                                    width: 150,
3684
                                    hidden: isHide,
3685
                                    summaryType: rec.Aggregator,
3686
                                });
3687
                            }
3688
                        }
3689
                        break
3690
                }
3691
            });
3692
            var featuretype = "summary";
3693
            if (groupField != "") {
3694
                featuretype = "groupingsummary";
3695
            }
3696
            var param = me.filter;
3697
            if (param == undefined) {
3698
                param = ''
3699
            }
3700
            var jsStoreGrid = new Ext.data.Store({
3701
                storeId: me.storeName,
3702
                autoLoad: autoLoad,
3703
                pageSize: me.pagesize,
3704
                proxy: {
3705
                    method: 'POST',
3706
                    type: 'ajax',
3707
                    url: '/UserControl/GetStorePagingAuth',
3708
                    extraParams: {
3709
                        tableName: me.tableName,
3710
                        param: param,
3711
                        menuId: MinovaUtil.GetMenuID()
3712
                    },
3713
                    reader: {
3714
                        type: 'json',
3715
                        root: 'data',
3716
                        totalProperty: 'totalRecords'
3717
                    }
3718
                },
3719
                groupField: groupField
3720
            });
3721
            Ext.applyIf(me, {
3722
                autoScroll: true,
3723
                enableLocking: false,
3724
                lockedGridConfig: {
3725
                    header: false,
3726
                    collapsible: true,
3727
                    width: 250,
3728
                    forceFit: false,
3729
                    listeners: {
3730
                        render: function (grid) {
3731
                            var pagingToolbar = grid.child('pagingtoolbar');
3732
                            if (pagingToolbar) {
3733
                                grid.remove(pagingToolbar, true);
3734
                            }
3735
                        }
3736
                    }
3737
                },
3738
                listeners: {
3739
                    viewready: function () {
3740
                        if (autoLoad == true) {
3741
                            this.getStore().loadPage(1);
3742
                        }
3743
                    },
3744
                    beforeedit: function () {
3745
                        return false;
3746
                    }
3747
                },
3748
                lockedViewConfig: {
3749
                    scroll: 'horizontal'
3750
                },
3751
                viewConfig: {
3752
                    emptyText: 'No Data Display',
3753
                    deferEmptyText: false
3754
                },
3755
                selModel: {},
3756
                columns: cols,
3757
                store: jsStoreGrid,
3758
                features: [{
3759
                    ftype: 'groupingsummary'
3760
                }
3761
                ],
3762
                plugins: [{
3763
                    ptype: 'gridfilters'
3764
                }
3765
                ]
3766
            });
3767
        }
3768
        me.callParent(arguments);
3769
    }
3770
});
3771
/*MinovaGrouping Grid*/
3772
Ext.define('MinovaUtil.MinovaES.MinovaGroupingGrid', {
3773
    extend: 'Ext.grid.Panel',
3774
    requires: ['Ext.grid.RowNumberer', 'Ext.grid.feature.Grouping'],
3775
    alias: 'widget.minovagroupinggrid',
3776
    tableName: undefined,
3777
    isLookup: undefined,
3778
    param: undefined,
3779
    pagesize: undefined,
3780
    storeName: undefined,
3781
    layoutType: undefined,
3782
    enableLocking: true,
3783
    autoLoad: undefined,
3784
    multiSelect: undefined,
3785
    getTableName: function () {
3786
        return this.tableName;
3787
    },
3788
    initComponent: function () {
3789
        var me = this;
3790
        var cols_ = [];
3791
        var fieldeditor = {};
3792
        var hasil = null;
3793
        var autoLoad = true;
3794
        var LangID = localStorage.LangId;
3795
        var fielGrid = 'rec.GridView == 1';
3796
        var locking = true;
3797
        var checkSelection = '';
3798
        var widthLock = 250;
3799
        var GroupField = '';
3800
        if (me.multiSelect) {
3801
            locking = false;
3802
            checkSelection = 'checkboxmodel';
3803
            widthLock = 40;
3804
        }
3805
        if (me.autoLoad == false) {
3806
            autoLoad = false;
3807
        }
3808
        parameter = null;
3809
        if (me.isLookup == 1 || me.isLookup == 'Y' || me.isLookup == true) {
3810
            parameter = "LangID='" + LangID + "',TableName='" + me.tableName + "',LookupGrid='1'";
3811
            fielGrid = 'rec.LookupGrid == 1';
3812
            locking = false;
3813
        } else {
3814
            parameter = "LangID='" + LangID + "',TableName='" + me.tableName + "'"
3815
        };
3816

    
3817
        Ext.Ajax.request({
3818
            async: false,
3819
            method: 'POST',
3820
            url: '/UserControl/GetStore',
3821
            params: {
3822
                tableName: 'PDSBS0007',
3823
                param: parameter
3824
            },
3825
            success: function (response) {
3826
                var results = Ext.decode(response.responseText);
3827
                hasil = results.data;
3828
            }
3829
        });
3830
        if (hasil.length > 0) {
3831
            Ext.each(hasil, function (rec) {
3832
                var null_ = null;
3833
                if (rec.SearchFunction == "group") {
3834
                    GroupField = rec.FieldName;
3835
                }
3836
                if (rec.IsPrimaryKey == true) {
3837
                    null_ = false;
3838
                }
3839
                if (rec.IsRequired == true) {
3840
                    null_ = false;
3841
                } else {
3842
                    null_ = true;
3843
                }
3844
                if (me.isLookup == 1 || me.isLookup == 'Y' || me.isLookup == true) {
3845
                    if (rec.LookupGrid == 1) {
3846
                        switch (rec.FormatRef) {
3847
                            case "date":
3848
                                cols_.push({
3849
                                    xtype: 'minovadatecolumn',
3850
                                    text: rec.HeaderTitle,
3851
                                    dataIndex: rec.FieldName,
3852
                                    width: 100,
3853
                                    filter: {
3854
                                        type: 'date',
3855
                                        itemDefaults: {
3856
                                            emptyText: 'Search for...'
3857
                                        }
3858
                                    }
3859
                                });
3860
                                break
3861
                            case "amount":
3862
                                cols_.push({
3863
                                    xtype: 'minovacurrancycolumn',
3864
                                    text: rec.HeaderTitle,
3865
                                    align: 'right',
3866
                                    dataIndex: rec.FieldName,
3867
                                    width: 100,
3868
                                    filter: {
3869
                                        type: 'number',
3870
                                        itemDefaults: {
3871
                                            emptyText: 'Search for...'
3872
                                        }
3873
                                    }
3874
                                });
3875
                                break
3876
                            case "amountencrypt":
3877
                                cols_.push({
3878
                                    xtype: 'minovaamountcolumn',
3879
                                    align: 'right',
3880
                                    text: rec.HeaderTitle,
3881
                                    dataIndex: rec.FieldName,
3882
                                    width: 100,
3883
                                    filter: {
3884
                                        type: 'string',
3885
                                        itemDefaults: {
3886
                                            emptyText: 'Search for...'
3887
                                        }
3888
                                    }
3889
                                });
3890
                                break
3891
                            case "datetime":
3892
                                cols_.push({
3893
                                    xtype: 'minovadatetimecolumn',
3894
                                    text: rec.HeaderTitle,
3895
                                    dataIndex: rec.FieldName,
3896
                                    width: 140,
3897
                                    filter: {
3898
                                        type: 'string',
3899
                                        itemDefaults: {
3900
                                            emptyText: 'Search for...'
3901
                                        }
3902
                                    }
3903
                                });
3904
                                break
3905
                            default:
3906
                                if (rec.DataRef == 'CREATEBY' || rec.DataRef == 'CHANGEBY') {
3907
                                    cols_.push({
3908
                                        text: rec.HeaderTitle,
3909
                                        dataIndex: rec.FieldName,
3910
                                        width: 100,
3911
                                        filter: {
3912
                                            type: 'string',
3913
                                            itemDefaults: {
3914
                                                emptyText: 'Search for...'
3915
                                            }
3916
                                        }
3917
                                    });
3918
                                } else if (rec.TableRef != "") {
3919
                                    if (rec.TableRef != null) {
3920
                                        var valueField = null;
3921
                                        var displayValue = null;
3922
                                        Ext.Ajax.request({
3923
                                            async: false,
3924
                                            method: 'POST',
3925
                                            url: '/UserControl/GetStore',
3926
                                            params: {
3927
                                                tableName: 'SDATATABLEFIELD',
3928
                                                param: 'TableName[equal]' + rec.TableRef
3929
                                            },
3930
                                            success: function (response) {
3931
                                                var results = Ext.decode(response.responseText);
3932
                                                data_ = results.data;
3933
                                                if (data_ != undefined) {
3934
                                                    valueField_ = $.grep(data_, function (r) {
3935
                                                        return r.ValueField == '1'
3936
                                                    });
3937
                                                    valueField = valueField_[0].FieldName
3938
                                                    displayValue_ = $.grep(data_, function (r) {
3939
                                                        return r.DisplayValue == '1'
3940
                                                    });
3941
                                                    displayValue = displayValue_[0].FieldName
3942
                                                }
3943
                                            }
3944
                                        });
3945
                                        var store_ = Ext.StoreMgr.lookup('store_' + rec.FieldName);
3946
                                        var count_ = 0;
3947
                                        if (store_) {
3948
                                            count_ = store_.count();
3949
                                        }
3950
                                        if (count_ == 0) {
3951
                                            Ext.create('Ext.data.Store', {
3952
                                                storeId: 'store_' + rec.FieldName,
3953
                                                //autoLoad: true,
3954
                                                proxy: {
3955
                                                    method: 'POST',
3956
                                                    type: 'ajax',
3957
                                                    url: '/UserControl/GetStore',
3958
                                                    extraParams: {
3959
                                                        tableName: rec.TableRef,
3960
                                                        param: rec.ParamCombo
3961
                                                    },
3962
                                                    reader: {
3963
                                                        type: 'json',
3964
                                                        root: 'data',
3965
                                                        totalProperty: 'data[0].TotalCount'
3966
                                                    }
3967
                                                }
3968
                                            })
3969
                                        }
3970
                                        cols_.push({
3971
                                            xtype: 'minovacombocolumn',
3972
                                            text: rec.HeaderTitle,
3973
                                            dataIndex: rec.FieldName,
3974
                                            valueField: valueField,
3975
                                            displayField: displayValue,
3976
                                            store: 'store_' + rec.FieldName,
3977
                                            filter: {
3978
                                                type: 'list',
3979
                                                itemDefaults: {
3980
                                                    emptyText: 'Search for...'
3981
                                                }
3982
                                            }
3983
                                        });
3984
                                    }
3985
                                } else {
3986
                                    cols_.push({
3987
                                        text: rec.HeaderTitle,
3988
                                        dataIndex: rec.FieldName,
3989
                                        filter: {
3990
                                            itemDefaults: {
3991
                                                emptyText: 'Search for...'
3992
                                            }
3993
                                        }
3994
                                    });
3995
                                }
3996
                                break
3997
                        }
3998
                    } else {
3999
                        cols_.push({
4000
                            text: rec.HeaderTitle,
4001
                            dataIndex: rec.FieldName,
4002
                            hidden: true,
4003
                            filter: {
4004
                                itemDefaults: {
4005
                                    emptyText: 'Search for...'
4006
                                }
4007
                            }
4008
                        });
4009
                    }
4010

    
4011
                } else {
4012
                    if (rec.GridView == 1) {
4013
                        switch (rec.FormatRef) {
4014
                            case "date":
4015
                                cols_.push({
4016
                                    xtype: 'minovadatecolumn',
4017
                                    text: rec.HeaderTitle,
4018
                                    dataIndex: rec.FieldName,
4019
                                    width: 100,
4020
                                    flex: 1,
4021
                                    filter: {
4022
                                        type: 'date',
4023
                                        itemDefaults: {
4024
                                            emptyText: 'Search for...'
4025
                                        }
4026
                                    }
4027
                                });
4028
                                break
4029
                            case "amountencrypt":
4030
                                cols_.push({
4031
                                    xtype: 'minovaamountcolumn',
4032
                                    align: 'right',
4033
                                    text: rec.HeaderTitle,
4034
                                    dataIndex: rec.FieldName,
4035
                                    width: 100,
4036
                                    flex: 1,
4037
                                    filter: {
4038
                                        type: 'string',
4039
                                        itemDefaults: {
4040
                                            emptyText: 'Search for...'
4041
                                        }
4042
                                    }
4043
                                });
4044
                                break
4045
                            case "amount":
4046
                                cols_.push({
4047
                                    xtype: 'minovacurrancycolumn',
4048
                                    text: rec.HeaderTitle,
4049
                                    align: 'right',
4050
                                    dataIndex: rec.FieldName,
4051
                                    width: 100,
4052
                                    flex: 1,
4053
                                    filter: {
4054
                                        type: 'number',
4055
                                        itemDefaults: {
4056
                                            emptyText: 'Search for...'
4057
                                        }
4058
                                    }
4059
                                });
4060
                                break
4061
                            case "datetime":
4062
                                cols_.push({
4063
                                    xtype: 'minovadatetimecolumn',
4064
                                    text: rec.HeaderTitle,
4065
                                    dataIndex: rec.FieldName,
4066
                                    width: 140,
4067
                                    flex: 1,
4068
                                    filter: {
4069
                                        type: 'string',
4070
                                        itemDefaults: {
4071
                                            emptyText: 'Search for...'
4072
                                        }
4073
                                    }
4074
                                });
4075
                                break
4076
                            default:
4077
                                if (rec.DataRef == 'CREATEBY' || rec.DataRef == 'CHANGEBY') {
4078
                                    cols_.push({
4079
                                        text: rec.HeaderTitle,
4080
                                        dataIndex: rec.FieldName,
4081
                                        width: 100,
4082
                                        flex: 1,
4083
                                        filter: {
4084
                                            type: 'string',
4085
                                            itemDefaults: {
4086
                                                emptyText: 'Search for...'
4087
                                            }
4088
                                        }
4089
                                    });
4090
                                } else if (rec.TableRef != "") {
4091
                                    if (rec.TableRef != null) {
4092
                                        var valueField = null;
4093
                                        var displayValue = null;
4094
                                        Ext.Ajax.request({
4095
                                            async: false,
4096
                                            method: 'POST',
4097
                                            url: '/UserControl/GetStore',
4098
                                            params: {
4099
                                                tableName: 'SDATATABLEFIELD',
4100
                                                param: 'TableName[equal]' + rec.TableRef
4101
                                            },
4102
                                            success: function (response) {
4103
                                                var results = Ext.decode(response.responseText);
4104
                                                data_ = results.data;
4105
                                                if (data_ != undefined) {
4106
                                                    valueField_ = $.grep(data_, function (r) {
4107
                                                        return r.ValueField == '1'
4108
                                                    });
4109
                                                    valueField = valueField_[0].FieldName
4110
                                                    displayValue_ = $.grep(data_, function (r) {
4111
                                                        return r.DisplayValue == '1'
4112
                                                    });
4113
                                                    displayValue = displayValue_[0].FieldName
4114
                                                }
4115
                                            }
4116
                                        });
4117
                                        var store_ = Ext.StoreMgr.lookup('store_' + rec.FieldName);
4118
                                        var count_ = 0;
4119
                                        if (store_) {
4120
                                            count_ = store_.count();
4121
                                        }
4122
                                        if (count_ == 0) {
4123
                                            Ext.create('Ext.data.Store', {
4124
                                                storeId: 'store_' + rec.FieldName,
4125
                                                autoLoad: false,
4126
                                                proxy: {
4127
                                                    method: 'POST',
4128
                                                    type: 'ajax',
4129
                                                    url: '/UserControl/GetStore',
4130
                                                    extraParams: {
4131
                                                        tableName: rec.TableRef,
4132
                                                        param: rec.ParamCombo
4133
                                                    },
4134
                                                    reader: {
4135
                                                        type: 'json',
4136
                                                        root: 'data',
4137
                                                        totalProperty: 'data[0].TotalCount'
4138
                                                    }
4139
                                                }
4140
                                            })
4141
                                        }
4142
                                        cols_.push({
4143
                                            xtype: 'minovacombocolumn',
4144
                                            text: rec.HeaderTitle,
4145
                                            dataIndex: rec.FieldName,
4146
                                            valueField: valueField,
4147
                                            displayField: displayValue,
4148
                                            store: 'store_' + rec.FieldName,
4149
                                            flex: 1,
4150
                                            filter: {
4151
                                                type: 'list',
4152
                                                itemDefaults: {
4153
                                                    emptyText: 'Search for...'
4154
                                                }
4155
                                            }
4156
                                        });
4157
                                    }
4158

    
4159
                                } else {
4160
                                    cols_.push({
4161
                                        text: rec.HeaderTitle,
4162
                                        dataIndex: rec.FieldName,
4163
                                        flex: 1,
4164
                                        filter: {
4165
                                            itemDefaults: {
4166
                                                emptyText: 'Search for...'
4167
                                            }
4168
                                        }
4169
                                    });
4170
                                }
4171
                                break
4172
                        }
4173
                    } else {
4174
                        cols_.push({
4175
                            text: rec.HeaderTitle,
4176
                            dataIndex: rec.FieldName,
4177
                            hidden: true,
4178
                            filter: {
4179
                                itemDefaults: {
4180
                                    emptyText: 'Search for...'
4181
                                }
4182
                            }
4183
                        });
4184
                    }
4185

    
4186
                }
4187
            });
4188
        }
4189
        var param_ = me.param;
4190
        if (param_ == undefined) {
4191
            param_ = ''
4192
        }
4193
        var jsStoreGrid = new Ext.data.Store({
4194
            storeId: me.storeName,
4195
            autoLoad: autoLoad,
4196
            pageSize: me.pagesize,
4197
            proxy: {
4198
                method: 'POST',
4199
                type: 'ajax',
4200
                url: '/UserControl/GetStorePagingAuth',
4201
                extraParams: {
4202
                    tableName: me.tableName,
4203
                    param: param_,
4204
                    menuId: MinovaUtil.GetMenuID()
4205
                },
4206
                reader: {
4207
                    type: 'json',
4208
                    root: 'data',
4209
                    totalProperty: 'totalRecords'
4210
                }
4211
            },
4212
            groupField: GroupField,
4213
            //sorters: ['tipe','cuisine','name'],
4214
        });
4215
        Ext.applyIf(me, {
4216
            autoScroll: true,
4217
            enableLocking: locking,
4218
            lockedGridConfig: {
4219
                header: false,
4220
                collapsible: true,
4221
                width: widthLock,
4222
                forceFit: locking,
4223
                listeners: {
4224
                    render: function (grid) {
4225
                        var pagingToolbar = grid.child('pagingtoolbar');
4226
                        if (pagingToolbar) {
4227
                            grid.remove(pagingToolbar, true);
4228
                        }
4229
                    }
4230
                }
4231
            },
4232
            listeners: {
4233
                viewready: function () {
4234
                    if (autoLoad == true) {
4235
                        this.getStore().loadPage(1);
4236
                    }
4237

    
4238
                },
4239
                beforeedit: function () {
4240
                    return false;
4241
                }
4242
            },
4243
            lockedViewConfig: {
4244
                scroll: 'horizontal'
4245
            },
4246
            viewConfig: {
4247
                emptyText: 'No Data Display',
4248
                deferEmptyText: false,
4249
                listeners: {
4250
                    refresh: function (dataview) {
4251
                        Ext.each(dataview.panel.columns, function (column) {
4252
                            if (column.autoSizeColumn == false)
4253
                                column.autoSizeColumn = true;
4254
                            column.autoSize();
4255
                        })
4256
                    }
4257
                }
4258
            },
4259
            selModel: {},
4260
            selType: checkSelection,
4261
            columns: cols_,
4262
            store: jsStoreGrid,
4263
            features: [{
4264
                ftype: 'grouping'
4265
            }
4266
            ],
4267
            plugins: [{
4268
                ptype: 'gridfilters'
4269
            }
4270
            ]
4271
        });
4272
        me.callParent(arguments);
4273
    }
4274
});
4275
/*Form ESS Generator*/
4276
Ext.define('MinovaUtil.MinovaES.MinovaWorkflowForm', {
4277
    extend: 'Ext.form.Panel',
4278
    alias: ['widget.MinovaWorkflowForm', 'widget.minovaworkflowform', 'widget.workflowform'],
4279
    formname: this.name,
4280
    bizprocid: undefined,
4281
    taskid: undefined,
4282
    tableName: undefined,
4283
    titleform: undefined,
4284
    resizable: true,
4285
    border: false,
4286
    autoScroll: true,
4287
    minHeight: 20,
4288
    layout: 'column',
4289
    listeners: {
4290
        render: function () {
4291
            if (this.titleform != undefined) {
4292
                this.setTitle(this.titleform);
4293
            }
4294
        },
4295
    },
4296
    defaults: {
4297
        layout: 'form',
4298
        xtype: 'container',
4299
        defaultType: 'textfield',
4300
        style: 'width: 50%',
4301
    },
4302
    initComponent: function () {
4303
        var col1 = [];
4304
        var col2 = [];
4305
        var col0 = [];
4306
        var me = this;
4307
        var LangID = localStorage.LangId;
4308
        var parameter = "LangID='" + LangID + "',BizProcessID='" + me.bizprocid + "',TaskID='" + me.taskid + "',TableName='" + me.tableName + "'";
4309
        var formname_ = me.name;
4310
        var nameTable_ = me.tableName;
4311
        Ext.Ajax.request({
4312
            async: false,
4313
            method: 'POST',
4314
            url: '/UserControl/GetStore',
4315
            params: {
4316
                tableName: 'PDSWFSTRUCTUREFIELD',
4317
                param: parameter
4318
            },
4319
            success: function (response) {
4320
                var results = Ext.decode(response.responseText);
4321
                hasil = results.data;
4322
            }
4323
        });
4324
        if (hasil.length > 0) {
4325
            Ext.each(hasil, function (rec) {
4326
                var formfield = undefined;
4327
                var readonly = false;
4328
                var ishidden = false;
4329
                var allowblank = true;
4330
                var startDt = null;
4331
                var endDt = null;
4332
                if (rec.FieldName == 'StartDate' || rec.FieldName == 'EndDate') {
4333
                    startDt = 'StartDate';
4334
                    endDt = 'EndDate';
4335
                }
4336
                if (rec.IsReadOnly == '1') {
4337
                    readonly = true;
4338
                }
4339
                if (rec.IsRequired == '1') {
4340
                    allowblank = false;
4341
                }
4342
                if (rec.IsVisible == '0') {
4343
                    ishidden = true;
4344
                }
4345
                if (rec.SearchType == "") //textfield
4346
                {
4347
                    switch (rec.FormatRef) {
4348
                        case "date":
4349
                            if (rec.FieldName == 'StartDate' || rec.FieldName == 'EndDate') {
4350
                                formfield = new Ext.form.DateField({
4351
                                    allowBlank: allowblank,
4352
                                    fieldLabel: rec.ScreenCaption,
4353
                                    readOnly: readonly,
4354
                                    msgTarget: 'side',
4355
                                    labelCls: 'label-minova',
4356
                                    labelWidth: 150,
4357
                                    hidden: ishidden,
4358
                                    name: rec.FieldName,
4359
                                    submitFormat: 'Ymd',
4360
                                    value: rec.DefaultValue,
4361
                                    anchor: '100%',
4362
                                    vtype: 'daterange',
4363
                                    start: startDt,
4364
                                    end: endDt,
4365
                                    formname: formname_,
4366
                                    nameTable: nameTable_,
4367
                                    hideMode: 'visibility',
4368
                                    listeners: {
4369
                                        change: function (val) {
4370
                                            var _label = val.name;
4371
                                            var _form = val.formname;
4372
                                            var _Value = val.getValue();
4373
                                            var target = rec.TriggerCombo;
4374
                                            var custumFunc = rec.SelectFunction;
4375
                                            if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
4376
                                                Ext.Ajax.request({
4377
                                                    async: false,
4378
                                                    method: 'POST',
4379
                                                    url: '/UserControl/GetStore',
4380
                                                    params: {
4381
                                                        tableName: 'PCMFUNC',
4382
                                                        param: 'FuncName[equal]' + rec.custumFunc + ',Active[=]1'
4383
                                                    },
4384
                                                    success: function (response) {
4385
                                                        var results = Ext.decode(response.responseText);
4386
                                                        data_ = results.data[0];
4387
                                                        if (data_ != undefined) {
4388
                                                            custumFunc = data_.FunctionCode;
4389
                                                        }
4390
                                                    }
4391
                                                });
4392
                                            }
4393
                                            var frm = Ext.ComponentQuery.query('form[name=' + _form + ']')[0];
4394
                                            if (frm) {
4395
                                                if (custumFunc) {
4396
                                                    eval(custumFunc)
4397
                                                }
4398
                                            }
4399
                                        }
4400
                                    }
4401
                                });
4402
                            } else {
4403
                                formfield = new Ext.form.DateField({
4404
                                    allowBlank: allowblank,
4405
                                    fieldLabel: rec.ScreenCaption,
4406
                                    readOnly: readonly,
4407
                                    msgTarget: 'side',
4408
                                    labelCls: 'label-minova',
4409
                                    labelWidth: 150,
4410
                                    hidden: ishidden,
4411
                                    name: rec.FieldName,
4412
                                    submitFormat: 'Ymd',
4413
                                    value: rec.DefaultValue,
4414
                                    anchor: '100%',
4415
                                    formname: formname_,
4416
                                    nameTable: nameTable_,
4417
                                    hideMode: 'visibility',
4418
                                    listeners: {
4419
                                        change: function (val) {
4420
                                            var _label = val.name;
4421
                                            var _form = val.formname;
4422
                                            var _Value = val.getValue();
4423
                                            var target = rec.TriggerCombo;
4424
                                            var custumFunc = rec.SelectFunction;
4425
                                            if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
4426
                                                Ext.Ajax.request({
4427
                                                    async: false,
4428
                                                    method: 'POST',
4429
                                                    url: '/UserControl/GetStore',
4430
                                                    params: {
4431
                                                        tableName: 'PCMFUNC',
4432
                                                        param: 'FuncName[equal]' + rec.custumFunc + ',Active[=]1'
4433
                                                    },
4434
                                                    success: function (response) {
4435
                                                        var results = Ext.decode(response.responseText);
4436
                                                        data_ = results.data[0];
4437
                                                        if (data_ != undefined) {
4438
                                                            custumFunc = data_.FunctionCode;
4439
                                                        }
4440
                                                    }
4441
                                                });
4442
                                            }
4443
                                            var frm = Ext.ComponentQuery.query('form[name=' + _form + ']')[0];
4444
                                            if (frm) {
4445
                                                if (custumFunc) {
4446
                                                    eval(custumFunc)
4447
                                                }
4448
                                            }
4449
                                        }
4450
                                    }
4451
                                });
4452
                            }
4453
                            break;
4454
                        case "time":
4455
                            formfield = new Ext.form.TimeField({
4456
                                allowBlank: allowblank,
4457
                                fieldLabel: rec.ScreenCaption,
4458
                                readOnly: readonly,
4459
                                labelCls: 'label-minova',
4460
                                labelWidth: 150,
4461
                                hidden: ishidden,
4462
                                name: rec.FieldName,
4463
                                msgTarget: 'side',
4464
                                format: 'Hi',
4465
                                submitFormat: 'Hi',
4466
                                increment: 5,
4467
                                value: rec.DefaultValue,
4468
                                anchor: '100%',
4469
                                formname: formname_,
4470
                                nameTable: nameTable_,
4471
                                listeners: {
4472
                                    change: function (val) {
4473
                                        var _label = val.name;
4474
                                        var _form = val.formname;
4475
                                        var _Value = val.getValue();
4476
                                        var target = rec.TriggerCombo;
4477
                                        var custumFunc = rec.SelectFunction;
4478
                                        if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
4479
                                            Ext.Ajax.request({
4480
                                                async: false,
4481
                                                method: 'POST',
4482
                                                url: '/UserControl/GetStore',
4483
                                                params: {
4484
                                                    tableName: 'PCMFUNC',
4485
                                                    param: 'FuncName[equal]' + custumFunc + ',Active[=]1'
4486
                                                },
4487
                                                success: function (response) {
4488
                                                    var results = Ext.decode(response.responseText);
4489
                                                    data_ = results.data[0];
4490
                                                    if (data_ != undefined) {
4491
                                                        custumFunc = data_.FunctionCode;
4492
                                                    }
4493
                                                }
4494
                                            });
4495
                                        }
4496
                                        var frm = Ext.ComponentQuery.query('form[name=' + _form + ']')[0];
4497
                                        if (frm) {
4498
                                            if (custumFunc) {
4499
                                                eval(custumFunc)
4500
                                            }
4501
                                        }
4502
                                    }
4503
                                }
4504
                            });
4505
                            break;
4506
                        case "amount":
4507
                            formfield = new Ext.form.TextField({
4508
                                allowBlank: allowblank,
4509
                                fieldLabel: rec.ScreenCaption,
4510
                                readOnly: readonly,
4511
                                labelCls: 'label-minova',
4512
                                labelWidth: 150,
4513
                                hidden: ishidden,
4514
                                name: rec.FieldName,
4515
                                msgTarget: 'side',
4516
                                value: rec.DefaultValue,
4517
                                maxLength: rec.Length,
4518
                                anchor: '100%',
4519
                                formname: formname_,
4520
                                nameTable: nameTable_,
4521
                                fieldStyle: 'text-align:right;',
4522
                                listeners: {
4523
                                    change: function (val) {
4524
                                        var _label = val.name;
4525
                                        var _form = val.formname;
4526
                                        var _Value = val.getValue();
4527
                                        var target = rec.TriggerCombo;
4528
                                        var custumFunc = rec.SelectFunction;
4529
                                        if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
4530
                                            Ext.Ajax.request({
4531
                                                async: false,
4532
                                                method: 'POST',
4533
                                                url: '/UserControl/GetStore',
4534
                                                params: {
4535
                                                    tableName: 'PCMFUNC',
4536
                                                    param: 'FuncName[equal]' + rec.custumFunc + ',Active[=]1'
4537
                                                },
4538
                                                success: function (response) {
4539
                                                    var results = Ext.decode(response.responseText);
4540
                                                    data_ = results.data[0];
4541
                                                    if (data_ != undefined) {
4542
                                                        custumFunc = data_.FunctionCode;
4543
                                                    }
4544
                                                }
4545
                                            });
4546
                                        }
4547
                                        var frm = Ext.ComponentQuery.query('form[name=' + _form + ']')[0];
4548
                                        if (frm) {
4549
                                            if (custumFunc) {
4550
                                                eval(custumFunc)
4551
                                            }
4552
                                        }
4553
                                    }
4554
                                }
4555
                            });
4556
                            break;
4557
                        case "file":
4558
                            formfield = new MinovaUtil.MinovaES.UploadFile({
4559
                                allowBlank: allowblank,
4560
                                fieldLabel: rec.ScreenCaption,
4561
                                readOnly: readonly,
4562
                                readOnlyCls: 'minova-readonly',
4563
                                hidden: ishidden,
4564
                                labelCls: 'label-minova',
4565
                                name: rec.FieldName,
4566
                                msgTarget: 'side',
4567
                                fieldname: rec.FieldName,
4568
                                IsPrimaryKey: rec.IsPrimaryKey,
4569
                                tableName: rec.TableRef,
4570
                                triggerCls: 'x-form-search-trigger',
4571
                                formtarget: me.formname,
4572
                                anchor: '100%',
4573
                                formname: formname_,
4574
                                nameTable: nameTable_,
4575
                                listeners: {
4576
                                    change: function (val) {
4577
                                        var _label = val.name;
4578
                                        var _form = val.formname;
4579
                                        var _Value = val.getValue();
4580
                                        var target = rec.TriggerCombo;
4581
                                        var custumFunc = rec.SelectFunction;
4582
                                        if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
4583
                                            Ext.Ajax.request({
4584
                                                async: false,
4585
                                                method: 'POST',
4586
                                                url: '/UserControl/GetStore',
4587
                                                params: {
4588
                                                    tableName: 'PCMFUNC',
4589
                                                    param: 'FuncName[equal]' + rec.custumFunc + ',Active[=]1'
4590
                                                },
4591
                                                success: function (response) {
4592
                                                    var results = Ext.decode(response.responseText);
4593
                                                    data_ = results.data[0];
4594
                                                    if (data_ != undefined) {
4595
                                                        custumFunc = data_.FunctionCode;
4596
                                                    }
4597
                                                }
4598
                                            });
4599
                                        }
4600
                                        var frm = Ext.ComponentQuery.query('form[name=' + _form + ']')[0];
4601
                                        if (frm) {
4602
                                            if (target) {
4603
                                                var f = frm.getForm().findField(target)
4604
                                                _store = f.getStore();
4605
                                                var _tbl = _store.proxy.extraParams.tableName;
4606
                                                var oldParam = _store.proxy.extraParams.param;
4607
                                                _store.proxy.extraParams = {
4608
                                                    tableName: _tbl,
4609
                                                    param: _label + '[=]' + _Value
4610
                                                };
4611
                                                _store.load();
4612
                                            }
4613
                                            if (custumFunc) {
4614
                                                eval(custumFunc)
4615
                                            }
4616
                                        }
4617
                                    }
4618
                                }
4619
                            });
4620
                            break;
4621
                        default:
4622
                            if (rec.DataType == 0) {
4623
                                if (rec.Length > 250) {
4624
                                    formfield = new Ext.form.TextArea({
4625
                                        allowBlank: allowblank,
4626
                                        fieldLabel: rec.ScreenCaption,
4627
                                        readOnly: readonly,
4628
                                        labelCls: 'label-minova',
4629
                                        labelWidth: 150,
4630
                                        hidden: ishidden,
4631
                                        name: rec.FieldName,
4632
                                        msgTarget: 'side',
4633
                                        value: rec.DefaultValue,
4634
                                        maxLength: rec.Length,
4635
                                        anchor: '100%',
4636
                                        formname: formname_,
4637
                                        nameTable: nameTable_,
4638
                                        listeners: {
4639
                                            change: function (val) {
4640
                                                var _label = val.name;
4641
                                                var _form = val.formname;
4642
                                                var _Value = val.getValue();
4643
                                                var target = rec.TriggerCombo;
4644
                                                var custumFunc = rec.SelectFunction;
4645
                                                if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
4646
                                                    Ext.Ajax.request({
4647
                                                        async: false,
4648
                                                        method: 'POST',
4649
                                                        url: '/UserControl/GetStore',
4650
                                                        params: {
4651
                                                            tableName: 'PCMFUNC',
4652
                                                            param: 'FuncName[equal]' + rec.custumFunc + ',Active[=]1'
4653
                                                        },
4654
                                                        success: function (response) {
4655
                                                            var results = Ext.decode(response.responseText);
4656
                                                            data_ = results.data[0];
4657
                                                            if (data_ != undefined) {
4658
                                                                custumFunc = data_.FunctionCode;
4659
                                                            }
4660
                                                        }
4661
                                                    });
4662
                                                }
4663
                                                var frm = Ext.ComponentQuery.query('form[name=' + _form + ']')[0];
4664
                                                if (frm) {
4665
                                                    if (custumFunc) {
4666
                                                        eval(custumFunc)
4667
                                                    }
4668
                                                }
4669
                                            }
4670
                                        }
4671
                                    });
4672
                                } else {
4673
                                    if (rec.FixedValue != '') {
4674
                                        var storeData = [];
4675
                                        var str = rec.FixedValue;
4676
                                        var hasil = str.split('||');
4677
                                        hasil.forEach(function (h) {
4678
                                            store_ = h.split('=')
4679
                                            storeData.push({
4680
                                                code: store_[0],
4681
                                                desc: store_[1],
4682
                                            });
4683
                                        });
4684
                                        formfield = new Ext.form.ComboBox({
4685
                                            allowBlank: allowblank,
4686
                                            fieldLabel: rec.ScreenCaption,
4687
                                            forceSelection: true,
4688
                                            readOnly: readonly,
4689
                                            labelCls: 'label-minova',
4690
                                            labelWidth: 150,
4691
                                            hidden: ishidden,
4692
                                            name: rec.FieldName,
4693
                                            msgTarget: 'side',
4694
                                            value: rec.DefaultValue,
4695
                                            anchor: '100%',
4696
                                            formname: formname_,
4697
                                            nameTable: nameTable_,
4698
                                            formtarget: me.formname,
4699
                                            store: Ext.create('Ext.data.Store', {
4700
                                                storeId: 'store' + rec.FieldName,
4701
                                                autoLoad: true,
4702
                                                data: storeData
4703

    
4704
                                            }),
4705
                                            listeners: {
4706
                                                change: function (val) {
4707
                                                    var _label = val.name;
4708
                                                    var _form = val.formtarget;
4709
                                                    var _Value = val.getValue();
4710
                                                    var target = rec.TriggerCombo;
4711
                                                    var custumFunc = rec.SelectFunction;
4712
                                                    var frm = Ext.ComponentQuery.query('form[name=' + _form + ']')[0];
4713
                                                    if (frm) {
4714
                                                        if (target) {
4715
                                                            var f = frm.getForm().findField(target)
4716
                                                            _store = f.getStore();
4717
                                                            var _tbl = _store.proxy.extraParams.tableName;
4718
                                                            var oldParam = _store.proxy.extraParams.param;
4719
                                                            _store.proxy.extraParams = {
4720
                                                                tableName: _tbl,
4721
                                                                param: _label + '[=]' + _Value
4722
                                                            };
4723
                                                            _store.load();
4724
                                                        }
4725
                                                        if (custumFunc) {
4726
                                                            eval(custumFunc)
4727
                                                        }
4728
                                                    }
4729
                                                }
4730
                                            },
4731
                                            queryMode: 'local',
4732
                                            valueField: 'code',
4733
                                            displayField: 'desc',
4734
                                        });
4735
                                    } else {
4736
                                        formfield = new Ext.form.TextField({
4737
                                            allowBlank: allowblank,
4738
                                            fieldLabel: rec.ScreenCaption,
4739
                                            readOnly: readonly,
4740
                                            labelCls: 'label-minova',
4741
                                            labelWidth: 150,
4742
                                            hidden: ishidden,
4743
                                            name: rec.FieldName,
4744
                                            msgTarget: 'side',
4745
                                            value: rec.DefaultValue,
4746
                                            maxLength: rec.Length,
4747
                                            anchor: '100%',
4748
                                            formname: formname_,
4749
                                            nameTable: nameTable_,
4750
                                            listeners: {
4751
                                                change: function (val) {
4752
                                                    var _label = val.name;
4753
                                                    var _form = val.formname;
4754
                                                    var _Value = val.getValue();
4755
                                                    var target = rec.TriggerCombo;
4756
                                                    var custumFunc = rec.SelectFunction;
4757
                                                    if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
4758
                                                        Ext.Ajax.request({
4759
                                                            async: false,
4760
                                                            method: 'POST',
4761
                                                            url: '/UserControl/GetStore',
4762
                                                            params: {
4763
                                                                tableName: 'PCMFUNC',
4764
                                                                param: 'FuncName[equal]' + rec.custumFunc + ',Active[=]1'
4765
                                                            },
4766
                                                            success: function (response) {
4767
                                                                var results = Ext.decode(response.responseText);
4768
                                                                data_ = results.data[0];
4769
                                                                if (data_ != undefined) {
4770
                                                                    custumFunc = data_.FunctionCode;
4771
                                                                }
4772
                                                            }
4773
                                                        });
4774
                                                    }
4775
                                                    var frm = Ext.ComponentQuery.query('form[name=' + _form + ']')[0];
4776
                                                    if (frm) {
4777
                                                        if (custumFunc) {
4778
                                                            eval(custumFunc)
4779
                                                        }
4780
                                                    }
4781
                                                }
4782
                                            }
4783
                                        });
4784
                                    }
4785
                                }
4786
                            } else if (rec.DataType == 1 || rec.DataType == 2) {
4787
                                formfield = new MinovaUtil.MinovaES.MinovaNumberField({
4788
                                    allowBlank: allowblank,
4789
                                    fieldLabel: rec.ScreenCaption,
4790
                                    readOnly: readonly,
4791
                                    labelCls: 'label-minova',
4792
                                    labelWidth: 150,
4793
                                    msgTarget: 'side',
4794
                                    hidden: ishidden,
4795
                                    name: rec.FieldName,
4796
                                    value: rec.DefaultValue,
4797
                                    maxLength: rec.Length,
4798
                                    anchor: '100%',
4799
                                    formname: formname_,
4800
                                    nameTable: nameTable_,
4801
                                    fieldStyle: 'text-align:right;',
4802
                                    listeners: {
4803
                                        change: function (val) {
4804
                                            var _label = val.name;
4805
                                            var _form = val.formname;
4806
                                            var _Value = val.getValue();
4807
                                            var target = rec.TriggerCombo;
4808
                                            var custumFunc = rec.SelectFunction;
4809
                                            if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
4810
                                                Ext.Ajax.request({
4811
                                                    async: false,
4812
                                                    method: 'POST',
4813
                                                    url: '/UserControl/GetStore',
4814
                                                    params: {
4815
                                                        tableName: 'PCMFUNC',
4816
                                                        param: 'FuncName[equal]' + rec.custumFunc + ',Active[=]1'
4817
                                                    },
4818
                                                    success: function (response) {
4819
                                                        var results = Ext.decode(response.responseText);
4820
                                                        data_ = results.data[0];
4821
                                                        if (data_ != undefined) {
4822
                                                            custumFunc = data_.FunctionCode;
4823
                                                        }
4824
                                                    }
4825
                                                });
4826
                                            }
4827
                                            var frm = Ext.ComponentQuery.query('form[name=' + _form + ']')[0];
4828
                                            if (frm) {
4829
                                                if (target) {
4830
                                                    var f = frm.getForm().findField(target)
4831
                                                    _store = f.getStore();
4832
                                                    var _tbl = _store.proxy.extraParams.tableName;
4833
                                                    var oldParam = _store.proxy.extraParams.param;
4834
                                                    _store.proxy.extraParams = {
4835
                                                        tableName: _tbl,
4836
                                                        param: _label + '[=]' + _Value
4837
                                                    };
4838
                                                    _store.load();
4839
                                                }
4840
                                                if (custumFunc) {
4841
                                                    eval(custumFunc)
4842
                                                }
4843
                                            }
4844
                                        }
4845
                                    }
4846
                                });
4847
                            } else if (rec.DataType == 3) {
4848
                                formfield = new Ext.form.TextField({
4849
                                    allowBlank: allowblank,
4850
                                    fieldLabel: rec.ScreenCaption,
4851
                                    readOnly: readonly,
4852
                                    labelCls: 'label-minova',
4853
                                    labelWidth: 150,
4854
                                    msgTarget: 'side',
4855
                                    hidden: ishidden,
4856
                                    name: rec.FieldName,
4857
                                    value: rec.DefaultValue,
4858
                                    maxLength: rec.Length,
4859
                                    precision: rec.Prec,
4860
                                    anchor: '100%',
4861
                                    formname: formname_,
4862
                                    nameTable: nameTable_,
4863
                                    fieldStyle: 'text-align:right;',
4864
                                    maskRe: '^[0-9]+(\.[0-9]{1,2})?$',
4865
                                    listeners: {
4866
                                        change: function (val) {
4867
                                            var _label = val.name;
4868
                                            var _form = val.formname;
4869
                                            var _Value = val.getValue();
4870
                                            var target = rec.TriggerCombo;
4871
                                            var custumFunc = rec.SelectFunction;
4872
                                            if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
4873
                                                Ext.Ajax.request({
4874
                                                    async: false,
4875
                                                    method: 'POST',
4876
                                                    url: '/UserControl/GetStore',
4877
                                                    params: {
4878
                                                        tableName: 'PCMFUNC',
4879
                                                        param: 'FuncName[equal]' + rec.custumFunc + ',Active[=]1'
4880
                                                    },
4881
                                                    success: function (response) {
4882
                                                        var results = Ext.decode(response.responseText);
4883
                                                        data_ = results.data[0];
4884
                                                        if (data_ != undefined) {
4885
                                                            custumFunc = data_.FunctionCode;
4886
                                                        }
4887
                                                    }
4888
                                                });
4889
                                            }
4890
                                            var frm = Ext.ComponentQuery.query('form[name=' + _form + ']')[0];
4891
                                            if (frm) {
4892
                                                if (target) {
4893
                                                    var f = frm.getForm().findField(target)
4894
                                                    _store = f.getStore();
4895
                                                    var _tbl = _store.proxy.extraParams.tableName;
4896
                                                    var oldParam = _store.proxy.extraParams.param;
4897
                                                    _store.proxy.extraParams = {
4898
                                                        tableName: _tbl,
4899
                                                        param: _label + '[=]' + _Value
4900
                                                    };
4901
                                                    _store.load();
4902
                                                }
4903
                                                if (custumFunc) {
4904
                                                    eval(custumFunc)
4905
                                                }
4906
                                            }
4907
                                        }
4908
                                    }
4909
                                });
4910
                            }
4911
                    }
4912
                } else if (rec.SearchType != "") {
4913
                    if (rec.SearchType == "0") //combobox
4914
                    {
4915
                        valueField = null;
4916
                        displayValue = null;
4917
                        if (rec.TableRef != "") {
4918
                            Ext.Ajax.request({
4919
                                async: false,
4920
                                method: 'POST',
4921
                                url: '/UserControl/GetStore',
4922
                                params: {
4923
                                    tableName: 'SDATATABLEFIELD',
4924
                                    param: 'TableName[equal]' + rec.TableRef
4925
                                },
4926
                                success: function (response) {
4927
                                    var results = Ext.decode(response.responseText);
4928
                                    data_ = results.data;
4929
                                    if (data_ != undefined) {
4930
                                        valueField_ = $.grep(data_, function (r) {
4931
                                            return r.ValueField == '1'
4932
                                        });
4933
                                        if (valueField_.length > 0) {
4934
                                            valueField = valueField_[0].FieldName
4935
                                        }
4936
                                        displayValue_ = $.grep(data_, function (r) {
4937
                                            return r.DisplayValue == '1'
4938
                                        });
4939
                                        if (displayValue_.length > 0) {
4940
                                            displayValue = displayValue_[0].FieldName
4941
                                        }
4942
                                    }
4943
                                }
4944
                            });
4945
                        }
4946
                        formfield = new Ext.form.ComboBox({
4947
                            allowBlank: allowblank,
4948
                            fieldLabel: rec.ScreenCaption,
4949
                            forceSelection: true,
4950
                            anyMatch: true,
4951
                            readOnly: readonly,
4952
                            labelCls: 'label-minova',
4953
                            labelWidth: 150,
4954
                            hidden: ishidden,
4955
                            msgTarget: 'side',
4956
                            name: rec.FieldName,
4957
                            formname: formname_,
4958
                            nameTable: nameTable_,
4959
                            value: rec.DefaultValue,
4960
                            width: '95%',
4961
                            store: Ext.create('Ext.data.Store', {
4962
                                storeId: 'store' + rec.FieldName,
4963
                                //autoLoad: false,
4964
                                proxy: {
4965
                                    method: 'POST',
4966
                                    type: 'ajax',
4967
                                    url: '/UserControl/GetStore',
4968
                                    extraParams: {
4969
                                        tableName: rec.TableRef,
4970
                                        param: rec.ParamCombo
4971
                                    },
4972
                                    reader: {
4973
                                        type: 'json',
4974
                                        root: 'data',
4975
                                        totalProperty: 'data[0].TotalCount'
4976
                                    }
4977
                                }
4978
                            }),
4979
                            formtarget: formname_,
4980
                            listeners: {
4981
                                afterrender: function (f) {
4982
                                    var store_ = f.getStore();
4983
                                    store_.load();
4984
                                },
4985
                                change: function (val) {
4986
                                    var _label = val.name;
4987
                                    var _form = val.formtarget;
4988
                                    var _Value = val.getValue();
4989
                                    var target = rec.TriggerCombo;
4990
                                    var custumFunc = rec.SelectFunction;
4991
                                    var frm = Ext.ComponentQuery.query('form[name=' + _form + ']')[0];
4992
                                    if (frm) {
4993

    
4994
                                        if (target) {
4995
                                            var f = frm.getForm().findField(target)
4996
                                            _store = f.getStore();
4997
                                            var _tbl = _store.proxy.extraParams.tableName;
4998
                                            var oldParam = _store.proxy.extraParams.param;
4999
                                            _store.proxy.extraParams = {
5000
                                                tableName: _tbl,
5001
                                                param: _label + '[=]' + _Value
5002
                                            };
5003
                                            _store.load();
5004
                                        }
5005
                                        if (custumFunc) {
5006
                                            eval(custumFunc)
5007
                                        }
5008
                                    }
5009
                                }
5010
                            },
5011
                            queryMode: 'local',
5012
                            displayField: displayValue,
5013
                            valueField: valueField,
5014
                        });
5015
                    } else if (rec.SearchType == '2') //Lookup
5016
                    {
5017
                        formfield = new MinovaUtil.MinovaES.MinovaLookupGrid({
5018
                            allowBlank: allowblank,
5019
                            fieldLabel: rec.ScreenCaption,
5020
                            readOnly: readonly,
5021
                            IsPrimaryKey: rec.IsPrimaryKey,
5022
                            msgTarget: 'side',
5023
                            labelCls: 'label-minova',
5024
                            labelWidth: 150,
5025
                            hidden: ishidden,
5026
                            name: rec.FieldName,
5027
                            tableName: rec.TableRef, //name tabel yang jadi ref-nya
5028
                            triggerCls: 'x-form-search-trigger',
5029
                            vtype: 'alphanum', // disable space
5030
                            formtarget: me.formname, // nama form  yang akan di set value-nya
5031
                            anchor: '100%',
5032
                            formname: formname_,
5033
                            nameTable: nameTable_,
5034
                            LookupFunction: rec.LookupFunction,
5035
                            SearchFunction: rec.SearchFunction,
5036
                            listeners: {
5037
                                change: function (val) {
5038
                                    var _label = val.name;
5039
                                    var _form = val.formname;
5040
                                    var _Value = val.getValue();
5041
                                    var target = rec.TriggerCombo;
5042
                                    var custumFunc = rec.SelectFunction;
5043
                                    if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
5044
                                        Ext.Ajax.request({
5045
                                            async: false,
5046
                                            method: 'POST',
5047
                                            url: '/UserControl/GetStore',
5048
                                            params: {
5049
                                                tableName: 'PCMFUNC',
5050
                                                param: 'FuncName[equal]' + rec.custumFunc + ',Active[=]1'
5051
                                            },
5052
                                            success: function (response) {
5053
                                                var results = Ext.decode(response.responseText);
5054
                                                data_ = results.data[0];
5055
                                                if (data_ != undefined) {
5056
                                                    custumFunc = data_.FunctionCode;
5057
                                                }
5058
                                            }
5059
                                        });
5060
                                    }
5061
                                    var frm = Ext.ComponentQuery.query('form[name=' + _form + ']')[0];
5062
                                    if (frm) {
5063

    
5064
                                        if (target) {
5065
                                            var f = frm.getForm().findField(target)
5066
                                            _store = f.getStore();
5067
                                            var _tbl = _store.proxy.extraParams.tableName;
5068
                                            var oldParam = _store.proxy.extraParams.param;
5069
                                            _store.proxy.extraParams = {
5070
                                                tableName: _tbl,
5071
                                                param: _label + '[=]' + _Value
5072
                                            };
5073
                                            _store.load();
5074
                                        }
5075

    
5076
                                        if (custumFunc) {
5077
                                            eval(custumFunc)
5078
                                        }
5079

    
5080
                                    }
5081

    
5082
                                },
5083

    
5084
                            },
5085
                        });
5086
                    } else if (rec.SearchType == '3') //lookup tree
5087
                    {
5088
                        formfield = new MinovaUtil.MinovaES.MinovaLookupTree({
5089
                            allowBlank: allowblank,
5090
                            fieldLabel: rec.ScreenCaption,
5091
                            readOnly: readonly,
5092
                            IsPrimaryKey: rec.IsPrimaryKey,
5093
                            labelCls: 'label-minova',
5094
                            labelWidth: 150,
5095
                            hidden: ishidden,
5096
                            name: rec.FieldName,
5097
                            msgTarget: 'side',
5098
                            triggerCls: 'x-form-search-trigger',
5099
                            treeSructure: rec.SearchFunction, //'O-O-P',
5100
                            objClassValue: rec.ParamCombo, //'O',
5101
                            formname: formname_,
5102
                            targetField: rec.FieldName,
5103
                            nameTable: nameTable_,
5104
                            editable: false,
5105
                            anchor: '100%',
5106
                            listeners: {
5107
                                change3: function (val) {
5108
                                    var _label = val.name;
5109
                                    var _form = val.formname;
5110
                                    var _Value = val.getValue();
5111
                                    var target = rec.TriggerCombo;
5112
                                    var custumFunc = rec.SelectFunction;
5113
                                    if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
5114
                                        Ext.Ajax.request({
5115
                                            async: false,
5116
                                            method: 'POST',
5117
                                            url: '/UserControl/GetStore',
5118
                                            params: {
5119
                                                tableName: 'PCMFUNC',
5120
                                                param: 'FuncName[equal]' + rec.custumFunc + ',Active[=]1'
5121
                                            },
5122
                                            success: function (response) {
5123
                                                var results = Ext.decode(response.responseText);
5124
                                                data_ = results.data[0];
5125
                                                if (data_ != undefined) {
5126
                                                    custumFunc = data_.FunctionCode;
5127
                                                }
5128
                                            }
5129
                                        });
5130
                                    }
5131
                                    var frm = Ext.ComponentQuery.query('form[name=' + _form + ']')[0];
5132
                                    if (frm) {
5133

    
5134
                                        if (target) {
5135
                                            var f = frm.getForm().findField(target)
5136
                                            _store = f.getStore();
5137
                                            var _tbl = _store.proxy.extraParams.tableName;
5138
                                            var oldParam = _store.proxy.extraParams.param;
5139
                                            _store.proxy.extraParams = {
5140
                                                tableName: _tbl,
5141
                                                param: _label + '[=]' + _Value
5142
                                            };
5143
                                            _store.load();
5144
                                        }
5145
                                        if (custumFunc) {
5146
                                            eval(custumFunc)
5147
                                        }
5148
                                    }
5149
                                },
5150
                                blur: function (val) {
5151
                                    //if(val.value.split('-').length != 2){
5152
                                    var _label = val.name;
5153
                                    var _form = val.formname;
5154
                                    var _Value = val.getValue();
5155
                                    var target = rec.TriggerCombo;
5156
                                    var custumFunc = rec.SelectFunction;
5157
                                    if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
5158
                                        Ext.Ajax.request({
5159
                                            async: false,
5160
                                            method: 'POST',
5161
                                            url: '/UserControl/GetStore',
5162
                                            params: {
5163
                                                tableName: 'PCMFUNC',
5164
                                                param: 'FuncName[equal]' + rec.custumFunc + ',Active[=]1'
5165
                                            },
5166
                                            success: function (response) {
5167
                                                var results = Ext.decode(response.responseText);
5168
                                                data_ = results.data[0];
5169
                                                if (data_ != undefined) {
5170
                                                    custumFunc = data_.FunctionCode;
5171
                                                }
5172
                                            }
5173
                                        });
5174
                                    }
5175
                                    var frm = Ext.ComponentQuery.query('form[name=' + _form + ']')[0];
5176
                                    if (frm) {
5177

    
5178
                                        if (target) {
5179
                                            var f = frm.getForm().findField(target)
5180
                                            _store = f.getStore();
5181
                                            var _tbl = _store.proxy.extraParams.tableName;
5182
                                            var oldParam = _store.proxy.extraParams.param;
5183
                                            _store.proxy.extraParams = {
5184
                                                tableName: _tbl,
5185
                                                param: _label + '[=]' + _Value
5186
                                            };
5187
                                            _store.load();
5188
                                        }
5189
                                        if (custumFunc) {
5190
                                            eval(custumFunc)
5191
                                        }
5192
                                    }
5193
                                    //}
5194
                                }
5195

    
5196
                            }
5197
                        });
5198
                    }
5199
                }
5200
                if (isDesk) {
5201
                    if (rec.ColumnNo == 1) {
5202
                        col1.push(formfield);
5203
                    } else if (rec.ColumnNo == 2) {
5204
                        col2.push(formfield);
5205
                    } else {
5206
                        col0.push(formfield);
5207
                    }
5208
                } else {
5209
                    if (rec.ColumnNo == 1 || rec.ColumnNo == 2) {
5210
                        col1.push(formfield);
5211
                    } else {
5212
                        col0.push(formfield);
5213
                    }
5214
                }
5215
                //if (isDesk) {
5216
                //    if (rec.ColumnNo == 1) {
5217
                //        col1.push(formfield);
5218
                //    } else {
5219
                //        col2.push(formfield);
5220
                //    }
5221
                //} else {
5222
                //    col1.push(formfield);
5223
                //}
5224

    
5225
            });
5226
        }
5227
        Ext.applyIf(me, {
5228
            items: [{
5229
                //width: 450,
5230
                style: 'width: 50%',
5231
                items: col1
5232
            }, {
5233
                //width: 450,
5234
                style: 'width: 50%',
5235
                items: col2
5236
                }, {
5237
                    //width: 450,
5238
                    hidden: true,
5239
                    items: col0
5240
                }
5241
            ],
5242
        });
5243
        this.callParent();
5244
    }
5245
});
5246
/*Gird ESS Generator*/
5247
Ext.define('MinovaUtil.MinovaES.MinovaWorkflowGrid', {
5248
    extend: 'Ext.grid.Panel',
5249
    requires: ['Ext.grid.RowNumberer'],
5250
    alias: 'widget.minovaworkflowgrid',
5251
    alternateClassName: 'Ext.grid.MinovaGrid',
5252
    tableName: undefined,
5253
    param: undefined,
5254
    pagesize: undefined,
5255
    storeName: undefined,
5256
    enableLocking: true,
5257
    autoLoad: undefined,
5258
    multiSelect: undefined,
5259
    formname: this.name,
5260
    bizprocid: undefined,
5261
    taskid: undefined,
5262
    initComponent: function () {
5263
        var me = this;
5264
        var cols_ = [];
5265
        var fieldeditor = {};
5266
        var hasil = null;
5267
        var autoLoad = true;
5268
        var locking = true;
5269
        var widthLock = 250;
5270
        if (me.autoLoad == false) {
5271
            autoLoad = false;
5272
        }
5273
        var LangID = MinovaUtil.GetLangID();
5274
        var parameter = "LangID='" + LangID + "',BizProcessID='" + me.bizprocid + "',TaskID='" + me.taskid + "',TableName='" + me.tableName + "'";
5275
        Ext.Ajax.request({
5276
            async: false,
5277
            method: 'POST',
5278
            url: '/UserControl/GetStore',
5279
            params: {
5280
                tableName: 'PDSWFSTRUCTUREFIELD',
5281
                param: parameter
5282
            },
5283
            success: function (response) {
5284
                var results = Ext.decode(response.responseText);
5285
                hasil = results.data;
5286
            }
5287
        });
5288

    
5289
        if (hasil.length > 0) {
5290
            Ext.each(hasil, function (rec) {
5291
                var readonly = false;
5292
                var ishidden = false;
5293
                var allowblank = true;
5294
                var null_ = null;
5295
                if (rec.IsReadOnly == '1') {
5296
                    readonly = true;
5297
                }
5298
                if (rec.IsRequired == '1') {
5299
                    allowblank = false;
5300
                }
5301
                if (rec.IsVisible == '1') {
5302
                    switch (rec.FormatRef) {
5303
                        case "date":
5304
                            cols_.push({
5305
                                xtype: 'minovadatecolumn',
5306
                                text: rec.HeaderTitle,
5307
                                dataIndex: rec.FieldName,
5308
                                width: 100
5309
                            });
5310
                            break
5311
                        case "amountencrypt":
5312
                            cols_.push({
5313
                                xtype: 'minovaamountcolumn',
5314
                                align: 'right',
5315
                                text: rec.HeaderTitle,
5316
                                dataIndex: rec.FieldName,
5317
                                width: 100
5318
                            });
5319
                            break
5320
                        case "amount":
5321
                            cols_.push({
5322
                                xtype: 'minovacurrancycolumn',
5323
                                align: 'right',
5324
                                text: rec.HeaderTitle,
5325
                                dataIndex: rec.FieldName,
5326
                                width: 100,
5327
                                filter: {
5328
                                    type: 'number',
5329
                                    itemDefaults: {
5330
                                        emptyText: 'Search for...'
5331
                                    }
5332
                                }
5333
                            });
5334
                            break
5335
                        case "datetime":
5336
                            cols_.push({
5337
                                xtype: 'minovadatetimecolumn',
5338
                                text: rec.HeaderTitle,
5339
                                dataIndex: rec.FieldName,
5340
                                width: 140,
5341
                                filter: {
5342
                                    type: 'string',
5343
                                    itemDefaults: {
5344
                                        emptyText: 'Search for...'
5345
                                    }
5346
                                }
5347
                            });
5348
                            break
5349
                        default:
5350
                            if (rec.TableRef != "") {
5351
                                if (rec.TableRef != null) {
5352
                                    var valueField = null;
5353
                                    var displayValue = null;
5354
                                    Ext.Ajax.request({
5355
                                        async: false,
5356
                                        method: 'POST',
5357
                                        url: '/UserControl/GetStore',
5358
                                        params: {
5359
                                            tableName: 'SDATATABLEFIELD',
5360
                                            param: 'TableName[equal]' + rec.TableRef
5361
                                        },
5362
                                        success: function (response) {
5363
                                            var results = Ext.decode(response.responseText);
5364
                                            data_ = results.data;
5365

    
5366
                                            if (data_ != undefined) {
5367
                                                if (data_.length > 0) {
5368
                                                    valueField_ = $.grep(data_, function (r) {
5369
                                                        return r.ValueField == '1'
5370
                                                    });
5371
                                                    valueField = valueField_[0].FieldName
5372
                                                    displayValue_ = $.grep(data_, function (r) {
5373
                                                        return r.DisplayValue == '1'
5374
                                                    });
5375
                                                    displayValue = displayValue_[0].FieldName
5376
                                                }
5377
                                            }
5378
                                        }
5379
                                    });
5380
                                    var store_ = Ext.StoreMgr.lookup('store_' + rec.FieldName);
5381
                                    var count_ = 0;
5382
                                    if (store_) {
5383
                                        count_ = store_.count();
5384
                                    }
5385
                                    if (count_ == 0) {
5386
                                        var storeRef = Ext.create('Ext.data.Store', {
5387
                                            storeId: 'store_' + rec.FieldName,
5388
                                            autoLoad: false,
5389
                                            proxy: {
5390
                                                method: 'POST',
5391
                                                type: 'ajax',
5392
                                                url: '/UserControl/GetStore',
5393
                                                extraParams: {
5394
                                                    tableName: rec.TableRef,
5395
                                                    param: rec.ParamCombo
5396
                                                },
5397
                                                reader: {
5398
                                                    type: 'json',
5399
                                                    root: 'data',
5400
                                                    totalProperty: 'data[0].TotalCount'
5401
                                                }
5402
                                            }
5403
                                        });
5404
                                        storeRef.load();
5405

    
5406
                                        //Ext.create('Ext.data.Store', {
5407
                                        //    storeId: 'store_' + rec.FieldName,
5408
                                        //    autoLoad: true,
5409
                                        //    proxy: {
5410
                                        //        method: 'POST',
5411
                                        //        type: 'ajax',
5412
                                        //        url: '/UserControl/GetStore',
5413
                                        //        extraParams: {
5414
                                        //            tableName: rec.TableRef,
5415
                                        //            param: rec.ParamCombo
5416
                                        //        },
5417
                                        //        reader: {
5418
                                        //            type: 'json',
5419
                                        //            root: 'data',
5420
                                        //            totalProperty: 'data[0].TotalCount'
5421
                                        //        }
5422
                                        //    }
5423
                                        //})
5424
                                    }
5425
                                    cols_.push({
5426
                                        xtype: 'minovacombocolumn',
5427
                                        text: rec.HeaderTitle,
5428
                                        dataIndex: rec.FieldName,
5429
                                        valueField: valueField,
5430
                                        displayField: displayValue,
5431
                                        store: 'store_' + rec.FieldName,
5432
                                        filter: {
5433
                                            type: 'list',
5434
                                            itemDefaults: {
5435
                                                emptyText: 'Search for...'
5436
                                            }
5437
                                        }
5438
                                    });
5439
                                }
5440
                            } else {
5441
                                cols_.push({
5442
                                    text: rec.HeaderTitle,
5443
                                    dataIndex: rec.FieldName,
5444
                                    filter: {
5445
                                        itemDefaults: {
5446
                                            emptyText: 'Search for...'
5447
                                        }
5448
                                    }
5449
                                });
5450
                            }
5451
                            break
5452
                    }
5453
                } else {
5454
                    cols_.push({
5455
                        text: rec.HeaderTitle,
5456
                        dataIndex: rec.FieldName,
5457
                        hidden: true,
5458
                        filter: {
5459
                            itemDefaults: {
5460
                                emptyText: 'Search for...'
5461
                            }
5462
                        }
5463
                    });
5464
                }
5465
            });
5466
        };
5467
        var param_ = me.param;
5468
        if (param_ == undefined) {
5469
            param_ = ''
5470
        }
5471
        var jsStoreGrid = new Ext.data.Store({
5472
            storeId: me.storeName,
5473
            autoLoad: autoLoad,
5474
            pageSize: 10,
5475
            proxy: {
5476
                method: 'POST',
5477
                type: 'ajax',
5478
                url: '/UserControl/GetStorePagingAuth',
5479
                extraParams: {
5480
                    tableName: me.tableName,
5481
                    param: param_,
5482
                    menuId: MinovaUtil.GetMenuID()
5483
                },
5484
                reader: {
5485
                    type: 'json',
5486
                    root: 'data',
5487
                    totalProperty: 'totalRecords'
5488
                }
5489
            }
5490
        });
5491
        Ext.applyIf(me, {
5492
            autoScroll: true,
5493
            enableLocking: locking,
5494
            lockedGridConfig: {
5495
                header: false,
5496
                collapsible: true,
5497
                width: widthLock,
5498
                forceFit: locking,
5499
                listeners: {
5500
                    render: function (grid) {
5501
                        var pagingToolbar = grid.child('pagingtoolbar');
5502
                        if (pagingToolbar) {
5503
                            grid.remove(pagingToolbar, true);
5504
                        }
5505
                    }
5506
                }
5507
            },
5508
            listeners: {
5509
                viewready: function () {
5510
                    if (autoLoad == false) {
5511
                        this.getStore().loadPage(1);
5512
                    }
5513

    
5514
                },
5515
                beforeedit: function () {
5516
                    return false;
5517
                }
5518
            },
5519
            lockedViewConfig: {
5520
                scroll: 'horizontal'
5521
            },
5522
            viewConfig: {
5523
                emptyText: 'No Data Display',
5524
                deferEmptyText: false,
5525
                listeners: {
5526
                    refresh: function (dataview) {
5527
                        Ext.each(dataview.panel.columns, function (column) {
5528
                            if (column.autoSizeColumn == false)
5529
                                column.autoSizeColumn = true;
5530
                            column.autoSize();
5531
                        })
5532
                    }
5533
                }
5534
            },
5535
            columns: cols_,
5536
            store: jsStoreGrid,
5537
            plugins: [{
5538
                ptype: 'gridfilters'
5539
            }
5540
            ]
5541
        });
5542
        this.callParent();
5543
    }
5544
});
5545
/*EditableGrid ESS Generator*/
5546
Ext.define('MinovaUtil.MinovaES.MinovaWorkflowEditableGrid', {
5547
    extend: 'Ext.form.Panel',
5548
    alias: ['widget.minovaworkfloweditablegrid', 'widget.workfloweditablegrid1'],
5549
    requires: [
5550
		'Ext.grid.plugin.CellEditing',
5551
		'Ext.grid.RowNumberer',
5552
		'Ext.grid.Panel',
5553
    ],
5554
    anchor: '100%',
5555
    tableName: undefined,
5556
    hideButton: undefined,
5557
    multiSelect: undefined,
5558
    formname: this.name,
5559
    bizprocid: undefined,
5560
    bizflowid: undefined,
5561
    taskid: undefined,
5562
	features: undefined,
5563
    initComponent: function () {
5564
        var me = this;
5565
        var isLookup = me.isLookup;
5566
        var hide_ = false;
5567
        var widthLock = 250;
5568
        var checkSelection = '';
5569
        if (me.hideButton == true) {
5570
            hide_ = true;
5571
        }
5572
        if (me.multiSelect) {
5573
            locking = false;
5574
            checkSelection = 'checkboxmodel';
5575
            widthLock = 40;
5576
        }
5577
        var tableName = me.tableName;
5578
		var features = me.features;
5579
        var cols = [];
5580
        var fieldStore = [];
5581
        var _url = 'GetAllField';
5582
        var hasil = null;
5583
        var height = me.height;
5584
        var storeID = 'store' + me.tableName;
5585
        var gridName = 'grid' + me.name;
5586
        if (me.storeName) {
5587
            storeID = me.storeName;
5588
        }
5589
        var LangID = MinovaUtil.GetLangID();
5590
        var parameter = "LangID='" + LangID + "',BizProcessID='" + me.bizprocid + "',TaskID='" + me.taskid + "',TableName='" + me.tableName + "'";
5591
        Ext.Ajax.request({
5592
            async: false,
5593
            method: 'POST',
5594
            url: '/UserControl/GetStore',
5595
            params: {
5596
                tableName: 'PDSWFSTRUCTUREFIELD',
5597
                param: parameter
5598
            },
5599
            success: function (response) {
5600
                var results = Ext.decode(response.responseText);
5601
                hasil = results.data;
5602
            }
5603
        });
5604
        cols.push({
5605
            xtype: 'rownumberer'
5606
        });
5607
        var addData = 'var data={';
5608
        if (hasil.length > 0) {
5609
            Ext.each(hasil, function (rec) {
5610
                fieldStore.push(rec.FieldName);
5611
                if (rec.FieldName != 'Sequence') {
5612
                    addData = addData + rec.FieldName + ":" + "'',";
5613
                }
5614
                var null_ = null;
5615
                var ReadOnly_ = false;
5616
                if (rec.IsRequired == '1') {
5617
                    null_ = false;
5618
                } else {
5619
                    null_ = true;
5620
                }
5621
                var Hidden_ = false;
5622
                if (rec.IsReadOnly == '1') {
5623
                    ReadOnly_ = true;
5624
                }
5625
                if (rec.IsVisible == '1') {
5626
                    switch (rec.FormatRef) {
5627
                        case "date":
5628
                            cols.push({
5629
                                xtype: 'minovadatecolumn',
5630
                                hidden: Hidden_,
5631
                                text: rec.HeaderTitle,
5632
                                dataIndex: rec.FieldName,
5633
                                filter: {
5634
                                    itemDefaults: {
5635
                                        emptyText: 'Search for...',
5636
                                    }
5637
                                },
5638
                                editor: {
5639
                                    allowBlank: null_,
5640
                                    xtype: 'datefield',
5641
                                    hideMode: 'visibility',
5642
                                    readOnly: ReadOnly_,
5643
                                    id: tableName + rec.FieldName,
5644
                                    fieldGrid: rec.FieldName,
5645
                                    nameTable: rec.TableName,
5646
                                    value: rec.DefaultValue
5647
                                }
5648
                            });
5649
                            break
5650
                        case "amount":
5651
                            cols.push({
5652
                                xtype: 'minovacurrancycolumn',
5653
                                align: 'right',
5654
                                text: rec.HeaderTitle,
5655
                                dataIndex: rec.FieldName,
5656
                                hidden: Hidden_,
5657
                                filter: {
5658
                                    itemDefaults: {
5659
                                        emptyText: 'Search for...'
5660
                                    }
5661
                                },
5662
                                editor: {
5663
                                    allowBlank: null_,
5664
                                    xtype: 'minovacurrencyfield',
5665
                                    readOnly: ReadOnly_,
5666
                                    id: tableName + rec.FieldName,
5667
                                    nameTable: rec.TableName,
5668
                                    fieldGrid: rec.FieldName,
5669
                                    fieldStyle: 'text-align:right;',
5670
                                    value: '0'
5671
                                }
5672
                            });
5673
                            break
5674
                        default:
5675
                            if (rec.DataRef == 'CREATEBY' || rec.DataRef == 'CHANGEBY' || rec.DataRef == 'CREATEDT' || rec.DataRef == 'CHANGEDT') {
5676
                                cols.push({
5677
                                    text: rec.HeaderTitle,
5678
                                    dataIndex: rec.FieldName,
5679
                                    width: 100,
5680
                                    filter: {
5681
                                        type: 'string',
5682
                                        itemDefaults: {
5683
                                            emptyText: 'Search for...'
5684
                                        }
5685
                                    }
5686
                                });
5687
                            } else if (rec.SearchType == '0') {
5688
                                var valueField = null;
5689
                                var displayValue = null;
5690
                                var TableRef = undefined;
5691
                                if (rec.TableRef != '') {
5692
                                    TableRef = rec.TableRef;
5693
                                    Ext.Ajax.request({
5694
                                        async: false,
5695
                                        method: 'POST',
5696
                                        url: '/UserControl/GetStore',
5697
                                        params: {
5698
                                            tableName: 'SDATATABLEFIELD',
5699
                                            param: 'TableName[equal]' + rec.TableRef
5700
                                        },
5701
                                        success: function (response) {
5702
                                            var results = Ext.decode(response.responseText);
5703
                                            data_ = results.data;
5704
                                            if (data_ != undefined) {
5705
                                                valueField_ = $.grep(data_, function (r) {
5706
                                                    return r.ValueField == '1'
5707
                                                });
5708
                                                valueField = valueField_[0].FieldName
5709
                                                displayValue_ = $.grep(data_, function (r) {
5710
                                                    return r.DisplayValue == '1'
5711
                                                });
5712
                                                displayValue = displayValue_[0].FieldName
5713
                                            }
5714
                                        }
5715
                                    });
5716
                                }
5717
                                Ext.create('Ext.data.Store', {
5718
                                    storeId: 'store_' + me.tableName + rec.FieldName,
5719
                                    autoLoad: true,
5720
                                    proxy: {
5721
                                        method: 'POST',
5722
                                        type: 'ajax',
5723
                                        url: '/UserControl/GetStoreAuth',
5724
                                        extraParams: {
5725
                                            tableName: TableRef,
5726
                                            param: rec.ParamCombo,
5727
                                            menuId: MinovaUtil.GetMenuID()
5728
                                        },
5729
                                        reader: {
5730
                                            type: 'json',
5731
                                            root: 'data',
5732
                                            totalProperty: 'data[0].TotalCount'
5733
                                        }
5734
                                    }
5735
                                });
5736
                                cols.push({
5737
                                    //xtype : 'minovacombocolumn',
5738
                                    hidden: Hidden_,
5739
                                    text: rec.HeaderTitle,
5740
                                    dataIndex: rec.FieldName,
5741
                                    //valueField : valueField,
5742
                                    //displayField : displayValue,
5743
                                    //store : 'store_' + me.tableName + rec.FieldName,
5744
                                    editor: {
5745
                                        allowBlank: null_,
5746
                                        xtype: 'minovacombobox',
5747
                                        readOnly: ReadOnly_,
5748
                                        id: rec.TableName + rec.FieldName,
5749
                                        nameTable: rec.TableName,
5750
                                        fieldGrid: rec.FieldName,
5751
                                        valueField: valueField,
5752
                                        displayField: displayValue,
5753
                                        store: 'store_' + me.tableName + rec.FieldName,
5754
                                        value: rec.DefaultValue
5755
                                    },
5756
                                    renderer: function (value) {
5757
                                        var store = Ext.data.StoreManager.lookup('store_' + me.tableName + rec.FieldName);
5758
                                        var index = store.find(valueField, value);
5759
                                        var val = "";
5760
                                        if (index != -1) {
5761
                                            var rc = store.getAt(index);
5762
                                            val = rc.get(displayValue);
5763
                                        } else {
5764
                                            val = value;
5765
                                        }
5766
                                        return val;
5767
                                    },
5768
                                    filter: {
5769
                                        type: 'list',
5770
                                        itemDefaults: {
5771
                                            emptyText: 'Search for...'
5772
                                        }
5773
                                    }
5774
                                });
5775
                            } else if (rec.SearchType == '5') {							
5776
                                var valueField = null;
5777
                                var displayValue = null;
5778
                                var AdditionaldisplayValue = null;
5779
                                var TableRef = undefined;
5780
                                if (rec.TableRef != '') {
5781
                                    TableRef = rec.TableRef;
5782
                                    Ext.Ajax.request({
5783
                                        async: false,
5784
                                        method: 'POST',
5785
                                        url: '/UserControl/GetStore',
5786
                                        params: {
5787
                                            tableName: 'SDATATABLEFIELD',
5788
                                            param: 'TableName[equal]' + rec.TableRef
5789
                                        },
5790
                                        success: function (response) {
5791
                                            var results = Ext.decode(response.responseText);
5792
                                            data_ = results.data;
5793
                                            if (data_ != undefined) {
5794
                                                valueField_ = $.grep(data_, function (r) {
5795
                                                    return r.ValueField == '1'
5796
                                                });
5797
                                                if (valueField_.length > 0) {
5798
                                                    valueField = valueField_[0].FieldName
5799
                                                }
5800

    
5801
                                                displayValue_ = $.grep(data_, function (r) {
5802
                                                    return r.DisplayValue == '1' || r.DisplayValue == '2'
5803
                                                });
5804
                                                if (displayValue_.length > 0) {
5805
                                                    displayValue = displayValue_[0].FieldName;
5806
                                                }
5807
                                                if (displayValue_.length >= 2) {
5808
                                                    AdditionaldisplayValue = displayValue_[1].FieldName
5809
                                                }
5810
                                            }
5811
                                        }
5812
                                    });
5813
                                }
5814
                                Ext.create('Ext.data.Store', {
5815
                                    storeId: 'store_' + me.tableName + rec.FieldName,
5816
                                    autoLoad: true,
5817
                                    proxy: {
5818
                                        method: 'POST',
5819
                                        type: 'ajax',
5820
                                        url: '/UserControl/GetStoreAuth',
5821
                                        extraParams: {
5822
                                            tableName: TableRef,
5823
                                            param: rec.ParamCombo,
5824
                                            menuId: MinovaUtil.GetMenuID()
5825
                                        },
5826
                                        reader: {
5827
                                            type: 'json',
5828
                                            root: 'data',
5829
                                            totalProperty: 'data[0].TotalCount'
5830
                                        }
5831
                                    }
5832
                                });
5833
                                cols.push({
5834
                                    //xtype : 'minovacombocolumn',
5835
                                    hidden: Hidden_,
5836
                                    text: rec.HeaderTitle,
5837
                                    dataIndex: rec.FieldName,
5838
                                    //valueField : valueField,
5839
                                    //displayField : displayValue,
5840
                                    //store : 'store_' + me.tableName + rec.FieldName,
5841
                                    tpl: Ext.create('Ext.XTemplate',
5842
                                            '<ul class="x-list-plain"><tpl for=".">',
5843
                                            '<li role="option" class="x-boundlist-item">{' + AdditionaldisplayValue + '} - {' + displayValue + '}</li>',
5844
                                            '</tpl></ul>'),
5845
                                    displayTpl: Ext.create('Ext.XTemplate',
5846
                                        '<tpl for=".">',
5847
                                        '{' + AdditionaldisplayValue + '} - {' + displayValue + '}',
5848
                                        '</tpl>'),
5849
                                    editor: {
5850
                                        allowBlank: null_,
5851
                                        xtype: 'combobox',
5852
                                        readOnly: ReadOnly_,
5853
                                        id: rec.TableName + rec.FieldName,
5854
                                        nameTable: rec.TableName,
5855
                                        fieldGrid: rec.FieldName,
5856
                                        valueField: valueField,
5857
                                        displayField: displayValue,
5858
                                        store: 'store_' + me.tableName + rec.FieldName,
5859
                                        value: rec.DefaultValue,
5860
                                        tpl: Ext.create('Ext.XTemplate',
5861
                                            '<ul class="x-list-plain"><tpl for=".">',
5862
                                            '<li role="option" class="x-boundlist-item">{' + AdditionaldisplayValue + '} - {' + displayValue + '}</li>',
5863
                                            '</tpl></ul>'),
5864
                                        displayTpl: Ext.create('Ext.XTemplate',
5865
                                            '<tpl for=".">',
5866
                                            '{' + AdditionaldisplayValue + '} - {' + displayValue + '}',
5867
                                            '</tpl>')
5868
                                    },
5869
                                    renderer: function (value) {
5870
                                        var store = Ext.data.StoreManager.lookup('store_' + me.tableName + rec.FieldName);
5871
                                        var index = store.find(valueField, value);
5872
                                        var val = "";
5873
                                        if (index != -1) {
5874
                                            var rc = store.getAt(index);
5875
                                            //val = rc.get(displayValue);
5876
                                            val = rc.get(AdditionaldisplayValue) + ' - ' + rc.get(displayValue);
5877
                                        } else {
5878
                                            val = value;
5879
                                        }
5880
                                        return val;
5881
                                    },
5882
                                    filter: {
5883
                                        type: 'list',
5884
                                        itemDefaults: {
5885
                                            emptyText: 'Search for...'
5886
                                        }
5887
                                    }
5888
                                });
5889
                            } else if (rec.SearchType == '2') {
5890
                                var triger = (rec.TriggerCombo).split('$');
5891
                                var targetField_ = triger[0];
5892
                                var fieldValue_ = triger[1];
5893
                                cols.push({
5894
                                    text: rec.HeaderTitle,
5895
                                    hidden: Hidden_,
5896
                                    dataIndex: rec.FieldName,
5897
                                    filter: {
5898
                                        itemDefaults: {
5899
                                            emptyText: 'Search for...'
5900
                                        }
5901
                                    },
5902
                                    editor: {
5903
                                        allowBlank: null_,
5904
                                        xtype: 'minovalookupgrid',
5905
                                        readOnly: ReadOnly_,
5906
                                        isGrid: true,
5907
                                        fieldTarget: targetField_,
5908
                                        fieldValue: fieldValue_,
5909
                                        isGrid: true,
5910
                                        id: tableName + rec.FieldName,
5911
                                        tableName: rec.TableRef,
5912
                                        triggerCls: 'x-form-search-trigger',
5913
                                        vtype: 'alphanum',
5914
                                        nameTable: rec.TableName,
5915
                                        fieldGrid: rec.FieldName,
5916
                                        listeners: {
5917
                                            change: function (val) {
5918
                                                var custumFunc = rec.SelectFunction;
5919
                                                if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
5920
                                                    Ext.Ajax.request({
5921
                                                        async: false,
5922
                                                        method: 'POST',
5923
                                                        url: '/UserControl/GetStore',
5924
                                                        params: {
5925
                                                            tableName: 'PCMFUNC',
5926
                                                            param: 'FuncName[equal]' + rec.custumFunc + ',Active[=]1'
5927
                                                        },
5928
                                                        success: function (response) {
5929
                                                            var results = Ext.decode(response.responseText);
5930
                                                            data_ = results.data[0];
5931
                                                            if (data_ != undefined) {
5932
                                                                custumFunc = data_.FunctionCode;
5933
                                                            }
5934
                                                        }
5935
                                                    });
5936
                                                }
5937
                                                if (custumFunc) {
5938
                                                    eval(custumFunc)
5939
                                                }
5940
                                            }
5941
                                        }
5942
                                    }
5943
                                });
5944
                            } else if (rec.SearchType == '3') {
5945
                                cols.push({
5946
                                    text: rec.HeaderTitle,
5947
                                    hidden: Hidden_,
5948
                                    dataIndex: rec.FieldName,
5949
                                    filter: {
5950
                                        itemDefaults: {
5951
                                            emptyText: 'Search for...'
5952
                                        }
5953
                                    },
5954
                                    editor: {
5955
                                        allowBlank: null_,
5956
                                        xtype: 'MinovaLookupTree',
5957
                                        readOnly: ReadOnly_,
5958
                                        id: tableName + rec.FieldName,
5959
                                        tableName: rec.TableRef,
5960
                                        triggerCls: 'x-form-search-trigger',
5961
                                        vtype: 'alphanum',
5962
                                        treeSructure: rec.SearchFunction,
5963
                                        objClassValue: rec.ParamCombo,
5964
                                        nameTable: rec.TableName,
5965
                                        fieldGrid: rec.FieldName,
5966
                                        listeners: {
5967
                                            change: function (val) {
5968
                                                var custumFunc = rec.SelectFunction;
5969
                                                if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
5970
                                                    Ext.Ajax.request({
5971
                                                        async: false,
5972
                                                        method: 'POST',
5973
                                                        url: '/UserControl/GetStore',
5974
                                                        params: {
5975
                                                            tableName: 'PCMFUNC',
5976
                                                            param: 'FuncName[equal]' + rec.custumFunc + ',Active[=]1'
5977
                                                        },
5978
                                                        success: function (response) {
5979
                                                            var results = Ext.decode(response.responseText);
5980
                                                            data_ = results.data[0];
5981
                                                            if (data_ != undefined) {
5982
                                                                custumFunc = data_.FunctionCode;
5983
                                                            }
5984
                                                        }
5985
                                                    });
5986
                                                }
5987
                                                if (custumFunc) {
5988
                                                    eval(custumFunc)
5989
                                                }
5990
                                            }
5991
                                        }
5992
                                    }
5993
                                });
5994
                            } else if (rec.SearchType != '0' && rec.SearchType != '1' && rec.SearchType != '3' && (rec.FieldName == 'EmployeeID' || rec.FieldName == 'ApplicantID' || rec.FieldName == 'EmployeeIDFrom' || rec.FieldName == 'EmployeeIDTo') && isLookup != true) {
5995
                                var triger = (rec.TriggerCombo).split('&');
5996
                                var targetField_ = triger[0];
5997
                                var fieldValue_ = triger[0];
5998
                                cols.push({
5999
                                    text: rec.HeaderTitle,
6000
                                    hidden: Hidden_,
6001
                                    dataIndex: rec.FieldName,
6002
                                    filter: {
6003
                                        itemDefaults: {
6004
                                            emptyText: 'Search for...'
6005
                                        }
6006
                                    },
6007
                                    editor: {
6008
                                        allowBlank: null_,
6009
                                        xtype: 'lookupemployee',
6010
                                        readOnly: ReadOnly_,
6011
                                        isGrid: true,
6012
                                        fieldTarget: targetField_,
6013
                                        fieldValue: fieldValue_,
6014
                                        isGrid: true,
6015
                                        id: tableName + rec.FieldName,
6016
                                        tableName: rec.TableRef, //name tabel yang jadi ref-nya
6017
                                        triggerCls: 'x-form-search-trigger',
6018
                                        vtype: 'alphanum', // disable space
6019
                                        nameTable: rec.TableName,
6020
                                        fieldGrid: rec.FieldName,
6021
                                        listeners: {
6022
                                            change: function (val) {
6023
                                                var custumFunc = rec.SelectFunction;
6024
                                                if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
6025
                                                    Ext.Ajax.request({
6026
                                                        async: false,
6027
                                                        method: 'POST',
6028
                                                        url: '/UserControl/GetStore',
6029
                                                        params: {
6030
                                                            tableName: 'PCMFUNC',
6031
                                                            param: 'FuncName[equal]' + rec.custumFunc + ',Active[=]1'
6032
                                                        },
6033
                                                        success: function (response) {
6034
                                                            var results = Ext.decode(response.responseText);
6035
                                                            data_ = results.data[0];
6036
                                                            if (data_ != undefined) {
6037
                                                                custumFunc = data_.FunctionCode;
6038
                                                            }
6039
                                                        }
6040
                                                    });
6041
                                                }
6042
                                                if (custumFunc) {
6043
                                                    eval(custumFunc)
6044
                                                }
6045
                                            }
6046
                                        }
6047
                                    }
6048
                                });
6049
                            } else if (rec.SearchType == '4' && isLookup != true) {
6050
                                cols.push({
6051
                                    text: rec.HeaderTitle,
6052
                                    hidden: Hidden_,
6053
                                    dataIndex: rec.FieldName,
6054
                                    filter: {
6055
                                        itemDefaults: {
6056
                                            emptyText: 'Search for...'
6057
                                        }
6058
                                    },
6059
                                    editor: {
6060
                                        allowBlank: null_,
6061
                                        xtype: 'lookupemployee',
6062
                                        readOnly: ReadOnly_,
6063
                                        isGrid: true,
6064
                                        fieldTarget: targetField_,
6065
                                        fieldValue: fieldValue_,
6066
                                        isGrid: true,
6067
                                        id: tableName + rec.FieldName,
6068
                                        tableName: rec.TableRef, //name tabel yang jadi ref-nya
6069
                                        triggerCls: 'x-form-search-trigger',
6070
                                        vtype: 'alphanum', // disable space
6071
                                        nameTable: rec.TableName,
6072
                                        fieldGrid: rec.FieldName,
6073
                                        listeners: {
6074
                                            change: function (val) {
6075
                                                var custumFunc = rec.SelectFunction;
6076
                                                if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
6077
                                                    Ext.Ajax.request({
6078
                                                        async: false,
6079
                                                        method: 'POST',
6080
                                                        url: '/UserControl/GetStore',
6081
                                                        params: {
6082
                                                            tableName: 'PCMFUNC',
6083
                                                            param: 'FuncName[equal]' + rec.custumFunc + ',Active[=]1'
6084
                                                        },
6085
                                                        success: function (response) {
6086
                                                            var results = Ext.decode(response.responseText);
6087
                                                            data_ = results.data[0];
6088
                                                            if (data_ != undefined) {
6089
                                                                custumFunc = data_.FunctionCode;
6090
                                                            }
6091
                                                        }
6092
                                                    });
6093
                                                }
6094
                                                if (custumFunc) {
6095
                                                    eval(custumFunc)
6096
                                                }
6097
                                            }
6098
                                        }
6099
                                    }
6100
                                });
6101
                            } else if (rec.FixedValue != '') { // add by taufan
6102
                                cols.push({
6103
                                    text: rec.HeaderTitle,
6104
                                    hidden: Hidden_,
6105
                                    dataIndex: rec.FieldName,
6106
                                    filter: {
6107
                                        itemDefaults: {
6108
                                            emptyText: 'Search for...'
6109
                                        }
6110
                                    },
6111
                                    editor: {
6112
                                        allowBlank: null_,
6113
                                        xtype: 'minovafixvalue',
6114
                                        readOnly: ReadOnly_,
6115
                                        id: rec.TableName + rec.FieldName,
6116
                                        name: rec.TableName + rec.FieldName,
6117
                                        nameTable: rec.TableName,
6118
                                        fieldGrid: rec.FieldName,
6119
                                        fixedValue: rec.FixedValue,
6120
                                        valueField: 'code',
6121
                                        displayField: 'desc',
6122
                                        value: rec.DefaultValue
6123
                                    },
6124
                                    renderer: function (value) {
6125
                                        var val = "";
6126
                                        var storeData = [];
6127
                                        var str = rec.FixedValue;
6128
                                        var hasil = str.split('||');
6129
                                        hasil.forEach(function (h) {
6130
                                            store_ = h.split('=')
6131
                                            storeData.push({
6132
                                                code: store_[0],
6133
                                                desc: store_[1]
6134
                                            });
6135
                                        });
6136
                                        var item = storeData.find(x => x.code == value);
6137
                                        if (item != undefined) {
6138
                                            val = item.desc;
6139
                                        }
6140
                                        return val;
6141
                                    }
6142
                                });
6143
                            } else {
6144
                                cols.push({
6145
                                    text: rec.HeaderTitle,
6146
                                    hidden: Hidden_,
6147
                                    dataIndex: rec.FieldName,
6148
                                    filter: {
6149
                                        itemDefaults: {
6150
                                            emptyText: 'Search for...'
6151
                                        }
6152
                                    },
6153
                                    editor: {
6154
                                        allowBlank: null_,
6155
                                        xtype: 'textfield',
6156
                                        readOnly: ReadOnly_,
6157
                                        id: tableName + rec.FieldName,
6158
                                        nameTable: rec.TableName,
6159
                                        fieldGrid: rec.FieldName,
6160
                                        value: rec.DefaultValue,
6161
                                        listeners: {
6162
                                            change: function (val) {
6163
                                                var custumFunc = null;
6164
                                                Ext.Ajax.request({
6165
                                                    async: false,
6166
                                                    method: 'POST',
6167
                                                    url: '/UserControl/GetStore',
6168
                                                    params: {
6169
                                                        tableName: 'SDATATABLEFIELD',
6170
                                                        param: 'FieldName[equal]' + rec.FieldName + ',TableName[equal]' + me.tableName
6171
                                                    },
6172
                                                    success: function (response) {
6173
                                                        var results = Ext.decode(response.responseText);
6174
                                                        data_ = results.data[0];
6175
                                                        if (data_ != undefined) {
6176
                                                            custumFunc = data_.SelectFunction;
6177
                                                            //console.log(data_)
6178
                                                        }
6179
                                                    }
6180
                                                });
6181

    
6182
                                                if (custumFunc) {
6183
                                                    eval(custumFunc)
6184
                                                }
6185
                                            }
6186
                                        }
6187
                                    }
6188
                                });
6189
                            }
6190
                            break
6191
                    }
6192
                } else {
6193
                    cols.push({
6194
                        text: rec.HeaderTitle,
6195
                        hidden: Hidden_,
6196
                        dataIndex: rec.FieldName,
6197
                        hidden: true,
6198
                        editor: {
6199
                            allowBlank: true,
6200
                            xtype: 'textfield',
6201
                            readOnly: ReadOnly_,
6202
                            id: tableName + rec.FieldName,
6203
                            nameTable: rec.TableName,
6204
                            fieldGrid: rec.FieldName,
6205
                            value: rec.DefaultValue
6206
                        },
6207
                        filter: {
6208
                            itemDefaults: {
6209
                                emptyText: 'Search for...'
6210
                            }
6211
                        }
6212
                    });
6213
                }
6214
            });
6215

    
6216
        };
6217
        addData = addData + "}";
6218
        Ext.applyIf(me, {
6219
            items: [{
6220
                xtype: 'grid',
6221
                id: gridName,
6222
                name: gridName,
6223
                height: height,
6224
                addFlag: true,
6225
                deleteFlag: true,
6226
                store: Ext.create('Ext.data.Store', {
6227
                    storeId: storeID,
6228
                    fields: fieldStore,
6229
					//groupField: 'QuestionGroup',
6230
					grouper: {
6231
						sortProperty: 'SeqQuest',
6232
						groupFn: function (record) {
6233
							return record.get('QuestionGroup');
6234
						}
6235
					},
6236
                    proxy: {
6237
                        method: 'POST',
6238
                        type: 'ajax',
6239
                        url: '',
6240
                        reader: {
6241
                            type: 'json',
6242
                            root: 'data'
6243
                        }
6244
                    }
6245
                }),
6246
                dockedItems: [{
6247
                    xtype: 'toolbar',
6248
                    items: [{
6249
                        text: 'Add',
6250
                        hidden: hide_,
6251
                        name: tableName + 'Add',
6252
                        iconCls: 'fa-plus-circle',
6253
                        style: 'font-family: FontAwesome',
6254
                        handler: function () {
6255
                            var grid = Ext.getCmp(gridName);
6256
                            if (grid.addFlag === true) {
6257
                                var store = Ext.StoreMgr.lookup(storeID)
6258
                                idx = store.getCount();
6259
                                var action = getParam('action');
6260
                                var data = '';
6261
                                var Sequence = 0;
6262
                                if (idx == 0) {
6263
                                    Sequence = 1;
6264
                                } else {
6265
                                    Sequence = 1 + idx;
6266
                                }
6267
                                var seq = 'Sequence';
6268
                                var SequenceValue = Sequence;
6269
                                eval(addData);
6270
                                data[seq] = SequenceValue;
6271
                                store.insert(idx, data);
6272
                            }
6273
                        }
6274
                    }, {
6275
                        text: 'Delete',
6276
                        hidden: hide_,
6277
                        name: tableName + 'DeleteText',
6278
                        iconCls: 'fa-trash-o',
6279
                        style: 'font-family: FontAwesome',
6280
                        handler: function () {
6281
                            var grid = Ext.getCmp(gridName);
6282
                            if (grid.deleteFlag === true) {
6283
                                var me = this,
6284
                                store = Ext.StoreMgr.lookup(storeID)
6285
                                var grid = Ext.getCmp(gridName);
6286
                                Ext.MessageBox.show({
6287
                                    title: 'Remove tab',
6288
                                    msg: "This will remove. Do you want to continue?",
6289
                                    buttons: Ext.MessageBox.YESNO,
6290
                                    fn: function (choice) {
6291
                                        console.log(choice);
6292
                                        if (choice === 'yes') {
6293
                                            var selection = grid.getView().getSelectionModel().getSelection()[0];
6294
                                            if (selection) {
6295
                                                store.remove(selection);
6296
                                            }
6297
                                        }
6298
                                    }
6299
                                });
6300
                            }
6301
                        }
6302
                    }
6303
                    ]
6304
                }
6305
                ],
6306
                columns: cols,
6307
                selType: checkSelection,
6308
                plugins: {
6309
                    ptype: 'rowediting',
6310
                    pluginId: 'rowEditing',
6311
                    clicksToEdit: 0,
6312
                    listeners: {}
6313
                },
6314
				features: features,
6315
				viewConfig: {
6316
                    listeners: {
6317
                        refresh: function (dataview) {
6318
                            Ext.each(dataview.panel.columns, function (column) {
6319
                                column.autoSize();
6320
                                column.setWidth(column.width + 20); //YN 220316
6321
                            })
6322
                        }
6323
                    }
6324
                }
6325
            }
6326
            ]
6327
        });
6328
        me.callParent(arguments);
6329
    }
6330
});
6331
Ext.define('MinovaUtil.MinovaES.MinovaWorkflowEditableGrid1', {
6332
    extend: 'Ext.form.Panel',
6333
    alias: ['widget.minovaworkfloweditablegrid1', 'widget.workfloweditablegrid1'],
6334
    requires: [
6335
		'Ext.grid.plugin.CellEditing',
6336
		'Ext.grid.Panel',
6337
    ],
6338
    anchor: '100%',
6339
    tableName: undefined,
6340
    hideButton: undefined,
6341
    multiSelect: undefined,
6342
    formname: this.name,
6343
    bizprocid: undefined,
6344
    bizflowid: undefined,
6345
    taskid: undefined,
6346
    initComponent: function () {
6347
        var me = this;
6348
        var hide_ = false;
6349
        var widthLock = 250;
6350
        var checkSelection = '';
6351

    
6352
        if (me.hideButton == true) {
6353
            hide_ = true;
6354
        }
6355
        if (me.multiSelect) {
6356
            locking = false;
6357
            checkSelection = 'checkboxmodel';
6358
            widthLock = 40;
6359
        }
6360
        var tableName = me.tableName;
6361
        var cols = [];
6362
        var fieldStore = [];
6363
        var _url = 'GetAllField';
6364
        var hasil = null;
6365
        var height = me.height;
6366
        var storeID = 'store' + me.tableName;
6367
        var gridName = 'grid' + me.name;
6368
        if (me.storeName) {
6369
            storeID = me.storeName;
6370
        }
6371
        var LangID = MinovaUtil.GetLangID();
6372
        var parameter = "LangID='" + LangID + "',BizProcessID='" + me.bizprocid + "',TaskID='" + me.taskid + "',TableName='" + me.tableName + "'";
6373
        Ext.Ajax.request({
6374
            async: false,
6375
            method: 'POST',
6376
            url: '/UserControl/GetStore',
6377
            params: {
6378
                tableName: 'PDSWFSTRUCTUREFIELD',
6379
                param: parameter
6380
            },
6381
            success: function (response) {
6382
                var results = Ext.decode(response.responseText);
6383
                hasil = results.data;
6384
            }
6385
        });
6386
        if (hasil.length > 0) {
6387
            Ext.each(hasil, function (rec) {
6388
                fieldStore.push(rec.FieldName)
6389
                var readonly = false;
6390
                var ishidden = false;
6391
                var allowblank = true;
6392
                if (rec.IsReadOnly == '1') {
6393
                    readonly = true;
6394
                }
6395
                if (rec.IsRequired == '1') {
6396
                    allowblank = false;
6397
                }
6398
                if (rec.IsVisible == '1') {
6399
                    switch (rec.FormatRef) {
6400
                        case "date":
6401
                            cols.push({
6402
                                xtype: 'minovadatecolumn',
6403
                                text: rec.HeaderTitle,
6404
                                dataIndex: rec.FieldName,
6405
                                editor: {
6406
                                    allowBlank: allowblank,
6407
                                    xtype: 'datefield',
6408
                                    hideMode: 'visibility',
6409
                                    readOnly: readonly,
6410
                                    name: 'grid' + tableName + rec.FieldName,
6411
                                    id: 'grid' + tableName + rec.FieldName,
6412
                                    value: rec.DefaultValue,
6413
                                    formname: me.formname,
6414
                                    listeners: {
6415
                                        change: function (val) {
6416
                                            var _label = val.name;
6417
                                            var _form = val.formname;
6418
                                            var _Value = val.getValue();
6419
                                            var target = rec.TriggerCombo;
6420
                                            var custumFunc = rec.SelectFunction;
6421
                                            if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
6422
                                                Ext.Ajax.request({
6423
                                                    async: false,
6424
                                                    method: 'POST',
6425
                                                    url: '/UserControl/GetStore',
6426
                                                    params: {
6427
                                                        tableName: 'PCMFUNC',
6428
                                                        param: 'FuncName[equal]' + custumFunc + ',Active[=]1'
6429
                                                    },
6430
                                                    success: function (response) {
6431
                                                        var results = Ext.decode(response.responseText);
6432
                                                        data_ = results.data[0];
6433
                                                        if (data_ != undefined) {
6434
                                                            custumFunc = data_.FunctionCode;
6435
                                                        }
6436
                                                    }
6437
                                                });
6438
                                            }
6439
                                            var frm = Ext.ComponentQuery.query('[name=' + _form + ']')[0];
6440
                                            if (frm) {
6441
                                                if (custumFunc) {
6442
                                                    eval(custumFunc)
6443
                                                }
6444
                                            }
6445
                                        }
6446
                                    }
6447
                                }
6448
                            });
6449
                            break;
6450
                        case "amount":
6451
                            cols.push({
6452
                                xtype: 'minovacurrancycolumn',
6453
                                align: 'right',
6454
                                text: rec.HeaderTitle,
6455
                                dataIndex: rec.FieldName,
6456
                                editor: {
6457
                                    allowBlank: allowblank,
6458
                                    xtype: 'textfield',
6459
                                    readOnly: readonly,
6460
                                    name: 'grid' + tableName + rec.FieldName,
6461
                                    id: 'grid' + tableName + rec.FieldName,
6462
                                    value: rec.DefaultValue
6463
                                }
6464
                            });
6465
                            break;
6466
                        case "time":
6467
                            cols.push({
6468
                                text: rec.HeaderTitle,
6469
                                dataIndex: rec.FieldName,
6470
                                editor: {
6471
                                    allowBlank: allowblank,
6472
                                    xtype: 'timefield',
6473
                                    readOnly: readonly,
6474
                                    name: 'grid' + tableName + rec.FieldName,
6475
                                    id: 'grid' + tableName + rec.FieldName,
6476
                                    msgTarget: 'side',
6477
                                    format: 'Hi',
6478
                                    submitFormat: 'Hi',
6479
                                    increment: 5,
6480
                                    value: rec.DefaultValue,
6481
                                    formname: me.formname,
6482
                                    listeners: {
6483
                                        change: function (val) {
6484
                                            var _label = val.name;
6485
                                            var _form = val.formname;
6486
                                            var _Value = val.getValue();
6487
                                            var target = rec.TriggerCombo;
6488
                                            var custumFunc = rec.SelectFunction;
6489
                                            if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
6490
                                                Ext.Ajax.request({
6491
                                                    async: false,
6492
                                                    method: 'POST',
6493
                                                    url: '/UserControl/GetStore',
6494
                                                    params: {
6495
                                                        tableName: 'PCMFUNC',
6496
                                                        param: 'FuncName[equal]' + custumFunc + ',Active[=]1'
6497
                                                    },
6498
                                                    success: function (response) {
6499
                                                        var results = Ext.decode(response.responseText);
6500
                                                        data_ = results.data[0];
6501
                                                        if (data_ != undefined) {
6502
                                                            custumFunc = data_.FunctionCode;
6503
                                                        }
6504
                                                    }
6505
                                                });
6506
                                            }
6507
                                            var frm = Ext.ComponentQuery.query('[name=' + _form + ']')[0];
6508
                                            if (frm) {
6509
                                                if (custumFunc) {
6510
                                                    eval(custumFunc)
6511
                                                }
6512
                                            }
6513
                                        }
6514
                                    }
6515
                                }
6516
                            });
6517
                            break;
6518
                        default:
6519
                            if (rec.SearchType != "") {
6520
                                if (rec.SearchType == "0") {
6521
                                    var valueField = null;
6522
                                    var displayValue = null;
6523
                                    var TableRef = undefined;
6524
                                    if (rec.TableRef != '') {
6525
                                        TableRef = rec.TableRef;
6526
                                        Ext.Ajax.request({
6527
                                            async: false,
6528
                                            method: 'POST',
6529
                                            url: '/UserControl/GetStore',
6530
                                            params: {
6531
                                                tableName: 'SDATATABLEFIELD',
6532
                                                param: 'TableName[equal]' + rec.TableRef
6533
                                            },
6534
                                            success: function (response) {
6535
                                                var results = Ext.decode(response.responseText);
6536
                                                data_ = results.data;
6537
                                                if (data_ != undefined) {
6538
                                                    valueField_ = $.grep(data_, function (r) {
6539
                                                        return r.ValueField == '1'
6540
                                                    });
6541
                                                    valueField = valueField_[0].FieldName
6542
                                                    displayValue_ = $.grep(data_, function (r) {
6543
                                                        return r.DisplayValue == '1'
6544
                                                    });
6545
                                                    displayValue = displayValue_[0].FieldName
6546
                                                }
6547
                                            }
6548
                                        });
6549
                                    }
6550
                                    //create Store
6551
                                    Ext.create('Ext.data.Store', {
6552
                                        storeId: 'store_' + me.tableName + rec.FieldName,
6553
                                        autoLoad: true,
6554
                                        proxy: {
6555
                                            method: 'POST',
6556
                                            type: 'ajax',
6557
                                            url: '/UserControl/GetStore',
6558
                                            extraParams: {
6559
                                                tableName: TableRef,
6560
                                                param: rec.ParamCombo
6561
                                            },
6562
                                            reader: {
6563
                                                type: 'json',
6564
                                                root: 'data',
6565
                                                totalProperty: 'data[0].TotalCount'
6566
                                            }
6567
                                        }
6568
                                    });
6569
                                    cols.push({
6570
                                        xtype: 'minovacombocolumn',
6571
                                        text: rec.HeaderTitle,
6572
                                        dataIndex: rec.FieldName,
6573
                                        valueField: valueField,
6574
                                        displayField: displayValue,
6575
                                        store: 'store_' + me.tableName + rec.FieldName,
6576
                                        editor: {
6577
                                            allowBlank: allowblank,
6578
                                            xtype: 'combobox',
6579
                                            readOnly: readonly,
6580
                                            name: 'grid' + tableName + rec.FieldName,
6581
                                            id: 'grid' + tableName + rec.FieldName,
6582
                                            valueField: valueField,
6583
                                            displayField: displayValue,
6584
                                            store: 'store_' + me.tableName + rec.FieldName,
6585
                                            value: rec.DefaultValue,
6586
                                            formname: me.formname,
6587
                                            listeners: {
6588
                                                change: function (val) {
6589
                                                    var _label = val.name;
6590
                                                    var _form = val.formname;
6591
                                                    var _Value = val.getValue();
6592
                                                    var target = rec.TriggerCombo;
6593
                                                    var custumFunc = rec.SelectFunction;
6594
                                                    if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
6595
                                                        Ext.Ajax.request({
6596
                                                            async: false,
6597
                                                            method: 'POST',
6598
                                                            url: '/UserControl/GetStore',
6599
                                                            params: {
6600
                                                                tableName: 'PCMFUNC',
6601
                                                                param: 'FuncName[equal]' + custumFunc + ',Active[=]1'
6602
                                                            },
6603
                                                            success: function (response) {
6604
                                                                var results = Ext.decode(response.responseText);
6605
                                                                data_ = results.data[0];
6606
                                                                if (data_ != undefined) {
6607
                                                                    custumFunc = data_.FunctionCode;
6608
                                                                }
6609
                                                            }
6610
                                                        });
6611
                                                    }
6612
                                                    var frm = Ext.ComponentQuery.query('[name=' + _form + ']')[0];
6613
                                                    if (frm) {
6614
                                                        if (custumFunc) {
6615
                                                            eval(custumFunc)
6616
                                                        }
6617
                                                    }
6618
                                                }
6619
                                            }
6620
                                        }
6621
                                    });
6622
                                } else if (rec.SearchType == "2") {
6623
                                    cols.push({
6624
                                        text: rec.HeaderTitle,
6625
                                        dataIndex: rec.FieldName,
6626
                                        editor: {
6627
                                            xtype: 'minovalookupgrid',
6628
                                            allowBlank: allowblank,
6629
                                            readOnly: readonly,
6630
                                            msgTarget: 'side',
6631
                                            labelCls: 'label-minova',
6632
                                            labelWidth: 150,
6633
                                            name: 'grid' + tableName + rec.FieldName,
6634
                                            id: 'grid' + tableName + rec.FieldName,
6635
                                            tableName: rec.TableRef, //name tabel yang jadi ref-nya
6636
                                            triggerCls: 'x-form-search-trigger',
6637
                                            vtype: 'alphanum', // disable space
6638
                                            formtarget: me.formname, // nama form  yang akan di set value-nya
6639
                                            anchor: '100%',
6640
                                            formname: me.formname,
6641
                                            listeners: {
6642
                                                change: function (val) {
6643
                                                    var _label = val.name;
6644
                                                    var _form = val.formname;
6645
                                                    var _Value = val.getValue();
6646
                                                    var target = rec.TriggerCombo;
6647
                                                    var custumFunc = rec.SelectFunction;
6648
                                                    if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
6649
                                                        Ext.Ajax.request({
6650
                                                            async: false,
6651
                                                            method: 'POST',
6652
                                                            url: '/UserControl/GetStore',
6653
                                                            params: {
6654
                                                                tableName: 'PCMFUNC',
6655
                                                                param: 'FuncName[equal]' + rec.custumFunc + ',Active[=]1'
6656
                                                            },
6657
                                                            success: function (response) {
6658
                                                                var results = Ext.decode(response.responseText);
6659
                                                                data_ = results.data[0];
6660
                                                                if (data_ != undefined) {
6661
                                                                    custumFunc = data_.FunctionCode;
6662
                                                                }
6663
                                                            }
6664
                                                        });
6665
                                                    }
6666
                                                    var frm = Ext.ComponentQuery.query('form[name=' + _form + ']')[0];
6667
                                                    if (frm) {
6668
                                                        if (target) {
6669
                                                            var f = frm.getForm().findField(target)
6670
                                                            _store = f.getStore();
6671
                                                            var _tbl = _store.proxy.extraParams.tableName;
6672
                                                            var oldParam = _store.proxy.extraParams.param;
6673
                                                            _store.proxy.extraParams = {
6674
                                                                tableName: _tbl,
6675
                                                                param: _label + '[=]' + _Value
6676
                                                            };
6677
                                                            _store.load();
6678
                                                        }
6679
                                                        if (custumFunc) {
6680
                                                            eval(custumFunc)
6681
                                                        }
6682

    
6683
                                                    }
6684

    
6685
                                                },
6686

    
6687
                                            }
6688
                                        }
6689
                                    });
6690
                                } else if (rec.SearchType == "3") {
6691
                                    cols.push({
6692
                                        text: rec.HeaderTitle,
6693
                                        dataIndex: rec.FieldName,
6694
                                        editor: {
6695
                                            xtype: 'minovalookuptree',
6696
                                            allowBlank: allowblank,
6697
                                            fieldLabel: rec.ScreenCaption,
6698
                                            readOnly: readonly,
6699
                                            labelCls: 'label-minova',
6700
                                            labelWidth: 150,
6701
                                            name: 'grid' + tableName + rec.FieldName,
6702
                                            id: 'grid' + tableName + rec.FieldName,
6703
                                            msgTarget: 'side',
6704
                                            triggerCls: 'x-form-search-trigger',
6705
                                            treeSructure: rec.SearchFunction, //'O-O-P',
6706
                                            objClassValue: rec.ParamCombo, //'O',
6707
                                            formname: me.formname,
6708
                                            targetField: rec.FieldName,
6709
                                            anchor: '100%',
6710
                                            listeners: {
6711
                                                change: function (val) {
6712
                                                    var _label = val.name;
6713
                                                    var _form = val.formname;
6714
                                                    var _Value = val.getValue();
6715
                                                    var target = rec.TriggerCombo;
6716
                                                    var custumFunc = rec.SelectFunction;
6717
                                                    if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
6718
                                                        Ext.Ajax.request({
6719
                                                            async: false,
6720
                                                            method: 'POST',
6721
                                                            url: '/UserControl/GetStore',
6722
                                                            params: {
6723
                                                                tableName: 'PCMFUNC',
6724
                                                                param: 'FuncName[equal]' + rec.custumFunc + ',Active[=]1'
6725
                                                            },
6726
                                                            success: function (response) {
6727
                                                                var results = Ext.decode(response.responseText);
6728
                                                                data_ = results.data[0];
6729
                                                                if (data_ != undefined) {
6730
                                                                    custumFunc = data_.FunctionCode;
6731
                                                                }
6732
                                                            }
6733
                                                        });
6734
                                                    }
6735
                                                    var frm = Ext.ComponentQuery.query('form[name=' + _form + ']')[0];
6736
                                                    if (frm) {
6737

    
6738
                                                        if (target) {
6739
                                                            var f = frm.getForm().findField(target)
6740
                                                            _store = f.getStore();
6741
                                                            var _tbl = _store.proxy.extraParams.tableName;
6742
                                                            var oldParam = _store.proxy.extraParams.param;
6743
                                                            _store.proxy.extraParams = {
6744
                                                                tableName: _tbl,
6745
                                                                param: _label + '[=]' + _Value
6746
                                                            };
6747
                                                            _store.load();
6748
                                                        }
6749
                                                        if (custumFunc) {
6750
                                                            eval(custumFunc)
6751
                                                        }
6752
                                                    }
6753
                                                }
6754
                                            }
6755
                                        }
6756
                                    });
6757
                                } else if (rec.SearchType == "4") {
6758
                                    cols.push({
6759
                                        text: rec.HeaderTitle,
6760
                                        dataIndex: rec.FieldName,
6761
                                        editor: {
6762
                                            xtype: 'lookupemployee',
6763
                                            allowBlank: allowblank,
6764
                                            fieldLabel: rec.ScreenCaption,
6765
                                            readOnly: readonly,
6766
                                            labelCls: 'label-minova',
6767
                                            name: 'grid' + tableName + rec.FieldName,
6768
                                            id: 'grid' + tableName + rec.FieldName,
6769
                                            msgTarget: 'side',
6770
                                            fieldname: rec.FieldName,
6771
                                            tableName: rec.TableRef, //name tabel yang jadi ref-nya
6772
                                            triggerCls: 'x-form-search-trigger',
6773
                                            vtype: 'alphanum', // disable space
6774
                                            formtarget: formname, // nama form  yang akan di set value-nya
6775
                                            isLookup: isLookup,
6776
                                            anchor: '100%',
6777
                                            formname: formname,
6778
                                            listeners: {
6779
                                                change: function (val) {
6780
                                                    var _label = val.name;
6781
                                                    var _form = val.formname;
6782
                                                    var _Value = val.getValue();
6783
                                                    var target = rec.TriggerCombo;
6784
                                                    var custumFunc = rec.SelectFunction;
6785
                                                    if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
6786
                                                        Ext.Ajax.request({
6787
                                                            async: false,
6788
                                                            method: 'POST',
6789
                                                            url: '/UserControl/GetStore',
6790
                                                            params: {
6791
                                                                tableName: 'PCMFUNC',
6792
                                                                param: 'FuncName[equal]' + rec.custumFunc + ',Active[=]1'
6793
                                                            },
6794
                                                            success: function (response) {
6795
                                                                var results = Ext.decode(response.responseText);
6796
                                                                data_ = results.data[0];
6797
                                                                if (data_ != undefined) {
6798
                                                                    custumFunc = data_.FunctionCode;
6799
                                                                }
6800
                                                            }
6801
                                                        });
6802
                                                    }
6803
                                                    var frm = Ext.ComponentQuery.query('form[name=' + _form + ']')[0];
6804
                                                    if (frm) {
6805

    
6806
                                                        if (target) {
6807
                                                            var f = frm.getForm().findField(target)
6808
                                                            _store = f.getStore();
6809
                                                            var _tbl = _store.proxy.extraParams.tableName;
6810
                                                            var oldParam = _store.proxy.extraParams.param;
6811
                                                            _store.proxy.extraParams = {
6812
                                                                tableName: _tbl,
6813
                                                                param: _label + '[=]' + _Value
6814
                                                            };
6815
                                                            _store.load();
6816
                                                        }
6817
                                                        if (custumFunc) {
6818
                                                            eval(custumFunc)
6819
                                                        }
6820

    
6821
                                                    }
6822

    
6823
                                                },
6824

    
6825
                                            },
6826
                                        }
6827
                                    });
6828
                                }
6829
                            } else {
6830
                                if (rec.FixedValue != "") {
6831
                                    var storeData = [];
6832
                                    var str = rec.FixedValue;
6833
                                    var hasil = str.split('||');
6834
                                    hasil.forEach(function (h) {
6835
                                        store_ = h.split('=')
6836
                                        storeData.push({
6837
                                            code: store_[0],
6838
                                            desc: store_[1],
6839
                                        });
6840
                                    });
6841
                                    cols.push({
6842
                                        xtype: 'minovacombocolumn',
6843
                                        text: rec.HeaderTitle,
6844
                                        dataIndex: rec.FieldName,
6845
                                        valueField: valueField,
6846
                                        displayField: displayValue,
6847
                                        store: Ext.create('Ext.data.Store', {
6848
                                            storeId: 'store' + rec.FieldName,
6849
                                            autoLoad: true,
6850
                                            data: storeData
6851

    
6852
                                        }),
6853
                                        editor: {
6854
                                            xtype: 'combobox',
6855
                                            allowBlank: allowblank,
6856
                                            forceSelection: true,
6857
                                            readOnly: readonly,
6858
                                            labelCls: 'label-minova',
6859
                                            labelWidth: 150,
6860
                                            name: 'grid' + tableName + rec.FieldName,
6861
                                            id: 'grid' + tableName + rec.FieldName,
6862
                                            msgTarget: 'side',
6863
                                            value: rec.DefaultValue,
6864
                                            anchor: '100%',
6865
                                            formname: me.formname,
6866
                                            formtarget: me.formname,
6867
                                            store: Ext.create('Ext.data.Store', {
6868
                                                storeId: 'store' + rec.FieldName,
6869
                                                autoLoad: true,
6870
                                                data: storeData
6871

    
6872
                                            }),
6873
                                            listeners: {
6874
                                                change: function (val) {
6875
                                                    var _label = val.name;
6876
                                                    var _form = val.formtarget;
6877
                                                    var _Value = val.getValue();
6878
                                                    var target = rec.TriggerCombo;
6879
                                                    var custumFunc = rec.SelectFunction;
6880
                                                    var frm = Ext.ComponentQuery.query('form[name=' + _form + ']')[0];
6881
                                                    if (frm) {
6882
                                                        if (target) {
6883
                                                            var f = frm.getForm().findField(target)
6884
                                                            _store = f.getStore();
6885
                                                            var _tbl = _store.proxy.extraParams.tableName;
6886
                                                            var oldParam = _store.proxy.extraParams.param;
6887
                                                            _store.proxy.extraParams = {
6888
                                                                tableName: _tbl,
6889
                                                                param: _label + '[=]' + _Value
6890
                                                            };
6891
                                                            _store.load();
6892
                                                        }
6893
                                                        if (custumFunc) {
6894
                                                            eval(custumFunc)
6895
                                                        }
6896
                                                    }
6897
                                                }
6898
                                            },
6899
                                            queryMode: 'local',
6900
                                            valueField: 'code',
6901
                                            displayField: 'desc',
6902
                                        }
6903
                                    })
6904
                                } else {
6905
                                    cols.push({
6906
                                        text: rec.HeaderTitle,
6907
                                        dataIndex: rec.FieldName,
6908
                                        editor: {
6909
                                            allowBlank: allowblank,
6910
                                            xtype: 'textfield',
6911
                                            readOnly: readonly,
6912
                                            name: 'grid' + tableName + rec.FieldName,
6913
                                            id: 'grid' + tableName + rec.FieldName,
6914
                                            value: rec.DefaultValue
6915
                                        }
6916
                                    });
6917
                                }
6918
                            }
6919
                            break;
6920
                    }
6921
                } else {
6922
                    cols.push({
6923
                        text: rec.HeaderTitle,
6924
                        dataIndex: rec.FieldName,
6925
                        hidden: true,
6926
                        editor: {
6927
                            allowBlank: true,
6928
                            xtype: 'textfield',
6929
                            readOnly: false,
6930
                            name: 'grid' + tableName + rec.FieldName,
6931
                            id: 'grid' + tableName + rec.FieldName,
6932
                        }
6933
                    });
6934
                }
6935
            });
6936
        };
6937

    
6938
        this.editing = Ext.create('Ext.grid.plugin.CellEditing');
6939
        Ext.applyIf(me, {
6940
            items: [{
6941
                xtype: 'grid',
6942
                id: gridName,
6943
                name: gridName,
6944
                height: height,
6945
                store: Ext.create('Ext.data.Store', {
6946
                    storeId: storeID,
6947
                    fields: fieldStore,
6948
                    proxy: {
6949
                        method: 'POST',
6950
                        type: 'ajax',
6951
                        url: '',
6952
                        reader: {
6953
                            type: 'json',
6954
                            root: 'data'
6955
                        }
6956
                    }
6957
                }),
6958
                dockedItems: [{
6959
                    xtype: 'toolbar',
6960
                    items: [{
6961
                        text: 'Add',
6962
                        hidden: hide_,
6963
                        name: tableName + 'Add',
6964
                        iconCls: 'fa-plus-circle',
6965
                        style: 'font-family: FontAwesome',
6966
                        handler: function () {
6967
                            var store = Ext.StoreMgr.lookup(storeID)
6968
                            idx = store.getCount();
6969
                            var action = getParam('action');
6970
                            var data = '';
6971
                            var Sequence = 0;
6972
                            if (idx == 0) {
6973
                                Sequence = 1;
6974
                            } else {
6975
                                Sequence = 1 + idx;
6976
                            }
6977
                            data = {
6978
                                Sequence: Sequence
6979
                            };
6980
                            store.insert(idx, data);
6981
                        }
6982
                    }, {
6983
                        text: 'Delete',
6984
                        hidden: hide_,
6985
                        name: tableName + 'DeleteText',
6986
                        iconCls: 'fa-trash-o',
6987
                        style: 'font-family: FontAwesome',
6988
                        handler: function () {
6989
                            var me = this,
6990
                            store = Ext.StoreMgr.lookup(storeID);
6991
                            var grid = Ext.getCmp(gridName);
6992
                            Ext.MessageBox.show({
6993
                                title: 'Remove tab',
6994
                                msg: "This will remove. Do you want to continue?",
6995
                                buttons: Ext.MessageBox.YESNO,
6996
                                fn: function (choice) {
6997
                                    console.log(choice);
6998
                                    if (choice === 'yes') {
6999
                                        var selection = grid.getView().getSelectionModel().getSelection()[0];
7000
                                        if (selection) {
7001
                                            store.remove(selection);
7002
                                        }
7003
                                    }
7004
                                }
7005
                            });
7006
                        }
7007
                    }
7008
                    ]
7009
                }
7010
                ],
7011
                columns: cols,
7012
                selType: checkSelection,
7013
                plugins: [this.editing],
7014
                // plugins: {
7015
                // ptype: 'rowediting',
7016
                // pluginId: 'rowEditing',
7017
                // clicksToEdit: 0,
7018
                // listeners: {
7019
                // }
7020
                // }
7021
            }
7022
            ]
7023
        });
7024
        me.callParent(arguments);
7025
    }
7026
});
7027
Ext.define('MinovaUtil.MinovaES.MinovaForm', {
7028
    extend: 'Ext.form.Panel',
7029
    alias: ['widget.minovaForm', 'widget.minovaform'],
7030
    tableName: undefined,
7031
    param: undefined,
7032
    titleform: undefined,
7033
    formname: this.name,
7034
    isLookup: undefined,
7035
    hidebutton: undefined,
7036
    //frame: true,
7037
    resizable: true,
7038
    border: false,
7039
    autoScroll: true,
7040
    minHeight: 20,
7041
    layout: 'column',
7042
    submitproc: undefined, //true if stil edit ,add
7043
    actionsubmit: undefined,
7044
    iseditform: undefined,
7045
    isFormReadOnly: undefined, // true== form di read only default false
7046
    isDisplay: undefined, // true if display only and false or undefined or empety if form can be edit
7047
    searchcustomization: undefined,
7048
    getIsFormReadOnly: function () {
7049
        return this.isFormReadOnly;
7050
    },
7051
    setIsFormReadOnly: function (value) {
7052
        var me = this;
7053
        me.isFormReadOnly = value;
7054
        return me;
7055
    },
7056
    getIsEditform: function () {
7057
        return this.iseditform;
7058
    },
7059
    setIsEditform: function (value) {
7060
        var me = this;
7061
        me.iseditform = value;
7062
        return me;
7063
    },
7064
    getActionSubmit: function () {
7065
        return this.actionsubmit;
7066
    },
7067
    setActionSubmit: function (value) {
7068
        var me = this;
7069
        me.actionsubmit = value;
7070
        return me;
7071
    },
7072
    getSubmitProc: function () {
7073
        return this.submitnproc;
7074
    },
7075
    setSubmitProc: function (value) {
7076
        var me = this;
7077
        me.submitnproc = value;
7078
        return me;
7079
    },
7080
    listeners: {
7081
        render: function () {
7082
            if (this.isLookup == 1 || this.isLookup == 'Y' || this.hidebutton == 1 || this.hidebutton == 'Y') {
7083
                var v = Ext.ComponentQuery.query('[name=formLookupFilter]')[0];
7084
                if (v) {
7085
                    v.setMaxHeight(200);
7086
                }
7087

    
7088
            }
7089
            if (this.titleform != undefined) {
7090
                this.setTitle(this.titleform);
7091
            }
7092
        },
7093

    
7094
    },
7095
    defaults: {
7096
        layout: 'form',
7097
        xtype: 'container',
7098
        defaultType: 'textfield',
7099
        style: 'width: 50%',
7100
        //height: 1000
7101
    },
7102
    initComponent: function () {
7103
        var col1 = [];
7104
        var col2 = [];
7105
        var me = this;
7106
        LangID = localStorage.LangId;
7107
        isLookup = me.isLookup;
7108
        //var _url = 'GetAllField';
7109

    
7110
        if (isLookup == 1 || isLookup == true || isLookup == 'Y') {}
7111
        isDisplay = me.isDisplay;
7112
        var hasil = null;
7113
        //hamid 200916
7114
        //Ext.Ajax.request({
7115
        //	async : false,
7116
        //	method : 'POST',
7117
        //	url : '/Devt/' + _url + '?tableName=' + me.tableName,
7118
        //	success : function (response) {
7119
        //		var results = Ext.decode(response.responseText);
7120
        //		hasil = results.data;
7121
        //	}
7122
        //});
7123
        //end
7124

    
7125

    
7126
        //hamid
7127
        //if (me.isLookup == 1 || isLookup == true || isLookup == 'Y') {
7128
        parameter = null;
7129
        if (me.isLookup == true || isLookup == 1 || isLookup == 'Y') {
7130
            parameter = "LangID='" + LangID + "',TableName='" + me.tableName + "',LookupFilter='1'"
7131
        } else if (me.searchcustomization == true) {
7132
            parameter = "LangID='" + LangID + "',TableName='" + me.tableName + "',IsCustomizationFilter='1'"
7133
        } else {
7134
            parameter = "LangID='" + LangID + "',TableName='" + me.tableName + "'"
7135
        }
7136
        Ext.Ajax.request({
7137
            async: false,
7138
            method: 'POST',
7139
            url: '/UserControl/GetStore',
7140
            params: {
7141
                tableName: 'PDSBS0007',
7142
                param: parameter
7143
            },
7144
            success: function (response) {
7145
                var results = Ext.decode(response.responseText);
7146
                hasil = results.data;
7147
            }
7148
        });
7149
        //end
7150
        if (hasil.length > 0) {
7151
            // hasil = hasil.sort(MinovaUtil.SortBy("Sequence"))
7152
            var me = this;
7153
            Ext.each(hasil, function (rec) {
7154
                var null_ = null;
7155
                if (rec.IsPrimaryKey == true) {
7156
                    null_ = false;
7157
                }
7158
                if (rec.IsRequired == true) {
7159
                    null_ = false;
7160
                } else {
7161
                    null_ = true;
7162
                }
7163
                var formfield = MinovaUtil.FieldGenerator.Form(me.name, rec, null_, isDisplay, me.tableName, me.isLookup);
7164
                var descField = undefined;
7165
                //if (isDisplay == true && rec.SearchType !='') {
7166
                //    descField = new Ext.form.Display({
7167
                //        fieldCode:'codeDisplay'+rec.name+rec.tableName,
7168
                //        allowBlank: true,
7169
                //        fieldLabel: 'Desc ' + rec.ScreenCaption,
7170
                //        readOnly: true,
7171
                //        maxLength: rec.Length,
7172
                //        anchor: '100%',
7173
                //        submitValue: false
7174
                //    });
7175
                //}
7176
                //else {
7177
                //    if (rec.SearchType == '2') {// lookup
7178
                //        descField = new Ext.form.TextField({
7179
                //            fieldCode: 'codeEdit' + rec.name + rec.tableName,
7180
                //            allowBlank: true,
7181
                //            fieldLabel: 'Desc ' + rec.ScreenCaption,
7182
                //            readOnly: true,
7183
                //            maxLength: rec.Length,
7184
                //            anchor: '100%',
7185
                //            submitValue: false
7186
                //        });
7187
                //    }
7188
                //    if (rec.SearchType == '3') {// tree
7189
                //        descField = new Ext.form.TextField({
7190
                //            fieldCode: 'codeEdit' + rec.name + rec.tableName,
7191
                //            allowBlank: true,
7192
                //            fieldLabel: 'Desc ' + rec.ScreenCaption,
7193
                //            readOnly: true,
7194
                //            maxLength: rec.Length,
7195
                //            anchor: '100%',
7196
                //            submitValue: false
7197
                //        });
7198
                //    }
7199
                //    if (rec.SearchType == '4' && me.isLookup != true) {
7200
                //        descField = new Ext.form.TextField({
7201
                //            fieldCode: 'codeEdit' + rec.name + rec.tableName,
7202
                //            allowBlank: true,
7203
                //            fieldLabel: 'Full Name',
7204
                //            readOnly: true,
7205
                //            maxLength: rec.Length,
7206
                //            anchor: '100%',
7207
                //            submitValue: false
7208
                //        });
7209
                //    }
7210

    
7211
                //}
7212

    
7213
                if (me.isLookup == true || isLookup == 1 || isLookup == 'Y') {
7214
                    col1.push(formfield);
7215
                    if (descField) {
7216
                        col1.push(descField)
7217
                    }
7218
                } else {
7219
                    if (isDesk) {
7220
                        if (rec.ColumnNo == 1) {
7221
                            col1.push(formfield);
7222
                            if (descField) {
7223
                                col1.push(descField)
7224
                            }
7225
                        } else {
7226
                            col2.push(formfield);
7227
                            if (descField) {
7228
                                col2.push(descField)
7229
                            }
7230
                        }
7231
                    } else {
7232
                        col1.push(formfield);
7233
                        if (descField) {
7234
                            col1.push(descField)
7235
                        }
7236
                    }
7237

    
7238
                }
7239

    
7240
                if (rec.IsPrimaryKey == 1 && me.isLookup == undefined) {
7241
                    formfieldKey = new Ext.form.TextField({
7242
                        hidden: true,
7243
                        name: "Key_" + rec.FieldName,
7244
                    });
7245
                    col2.push(formfieldKey);
7246
                }
7247

    
7248
            });
7249
            //console.log(col1);
7250
        }
7251
        Ext.applyIf(me, {
7252
            items: [{
7253
                //width: 450,
7254
                style: 'width: 50%',
7255
                items: col1
7256
            }, {
7257
                //width: 450,
7258
                style: 'width: 50%',
7259
                items: col2
7260
            }
7261
            ],
7262
        });
7263
        this.callParent();
7264
    }
7265
});
7266

    
7267
Ext.define('MinovaUtil.MinovaES.MinovaGridForm', {
7268
    extend: 'Ext.form.Panel',
7269
    alias: ['widget.minovagridform', 'widget.MinovaGridForm'],
7270
    tableName: undefined, //nama tabel
7271
    param: undefined, //param query
7272
    pagesize: undefined,
7273
    storename: undefined,
7274
    titleform: undefined,
7275
    titlegrid: undefined,
7276
    heightgrid: undefined,
7277
    heightform: undefined,
7278
    iseditform: undefined,
7279
    lastheightform: undefined,
7280
    layoutType: undefined,
7281
    lastpage: undefined,
7282
    lastTitle: undefined,
7283
    getLastTitle: function () {
7284
        return this.lastTitle;
7285
    },
7286
    setLastTitle: function (value) {
7287
        var me = this;
7288
        me.lastTitle = value;
7289
        return me;
7290
    },
7291
    getLastpage: function () {
7292
        return this.lastpage;
7293
    },
7294
    setLastpage: function (value) {
7295
        var me = this;
7296
        me.lastpage = value;
7297
        return me;
7298
    },
7299
    getLayoutType: function () {
7300
        return this.layoutType;
7301
    },
7302
    setLayoutType: function (value) {
7303
        var me = this;
7304
        me.layoutType = value;
7305
        return me;
7306
    },
7307
    getLastheightform: function () {
7308
        return this.lastheightform;
7309
    },
7310
    setLastheightform: function (value) {
7311
        var me = this;
7312
        me.lastheightform = value;
7313
        return me;
7314
    },
7315

    
7316
    getIsEditform: function () {
7317
        return this.iseditform;
7318
    },
7319
    setIsEditform: function (value) {
7320
        var me = this;
7321
        me.iseditform = value;
7322
        return me;
7323
    },
7324
    initComponent: function () {
7325
        var me = this;
7326
        var storename = me.storename;
7327
        if (storename == "" || storename == undefined) {
7328
            storename = "store" + me.tableName;
7329
        }
7330
        var tableName = me.tableName;
7331
        Ext.applyIf(me, {
7332
            items: [{
7333
                layoutType: "MinovaGridForm",
7334
                title: me.titlegrid,
7335
                xtype: "minovagrid",
7336
                tableName: tableName, // nama tebel/dataset
7337
                name: "MinovaGridFormGrid" + tableName, //name bebeas
7338
                param: me.param, // parameter filteran
7339
                pagesize: me.pagesize, // jumlah record yang muncul per page
7340
                storename: storename, //nama store bebas
7341
                isLookup: me.isLookup, // apakah grid untuk look up? jika ya isi dengan 1 atau 'Y' kalau bukan isi string kosong
7342
                height: 330,
7343
                bodyPadding: 0,
7344
                dockedItems: [{
7345
                    xtype: 'pagingtoolbar',
7346
                    store: storename, // harus sama dengan naa store diatas
7347
                    dock: 'bottom', //posisi paging
7348
                    pageSize: me.pagesize,
7349
                    displayInfo: true
7350
                }
7351
                ],
7352

    
7353
                listeners: {
7354
                    viewready: function () {
7355
                        //alert('ready')
7356
                        var formEdit = Ext.ComponentQuery.query('[name=MinovaGridFormEdit' + this.tableName + ']')[0];
7357
                        formEdit.setHidden(true);
7358

    
7359
                        if (MinovaUtil.GetActionMenu() == 0 || MinovaUtil.GetActionMenu() == undefined || MinovaUtil.GetActionMenu() == "") {
7360
                            Ext.ComponentQuery.query('[name=actionBtn]')[0].setHidden(true)
7361
                            Ext.ComponentQuery.query('[name=Edit' + me.tableName + ']')[0].setHidden(true)
7362
                            Ext.ComponentQuery.query('[name=Delete_]')[0].setHidden(true)
7363
                        } else {
7364
                            Ext.ComponentQuery.query('[name=actionBtn]')[0].setHidden(false)
7365
                            //Ext.ComponentQuery.query('[name=Edit_]')[0].setHidden(true)
7366
                            Ext.ComponentQuery.query('[name=Delete_]')[0].setHidden(true)
7367
                            Ext.ComponentQuery.query('[name=Edit' + me.tableName + ']')[0].setHidden(false)
7368
                        }
7369
                    },
7370
                    selectionchange: function () {
7371
                        //case md
7372
                        var layout = null;
7373
                        var pnl = Ext.ComponentQuery.query('[name=MinovaMdDetail]')[0];
7374
                        if (pnl) {
7375
                            layout = pnl.getLayoutType();
7376

    
7377
                        }
7378
                        //end case
7379

    
7380
                        if (layout == 'L003') {
7381
                            var selection = this.getView().getSelectionModel().getSelection()[0];
7382
                            var formDisplay = Ext.ComponentQuery.query('[name=MinovaGridFormDisplay' + this.tableName + ']')[0];
7383
                            var formEdit = Ext.ComponentQuery.query('[name=MinovaGridFormEdit' + this.tableName + ']')[0];
7384
                            if (selection) {
7385
                                formDisplay.getForm().setValues(selection.data);
7386
                                formEdit.getForm().setValues(selection.data);
7387
                            }
7388

    
7389
                        }
7390
                    },
7391
                    itemdblclick: function () {
7392
                        var me = this;
7393
                        //case md
7394
                        var layout = null;
7395
                        var pnl = Ext.ComponentQuery.query('[name=MinovaMdDetail]')[0];
7396
                        if (pnl) {
7397
                            layout = pnl.getLayoutType();
7398

    
7399
                        } else {
7400
                            pnl = Ext.ComponentQuery.query('[name=MinovaORMDetail]')[0];
7401
                            layout = pnl.getLayoutType();
7402
                        }
7403
                        //end case
7404
                        var formDisplay = Ext.ComponentQuery.query('[name=MinovaGridFormDisplay' + this.tableName + ']')[0];
7405
                        var formEdit = Ext.ComponentQuery.query('[name=MinovaGridFormEdit' + this.tableName + ']')[0];
7406
                        var submit_ = formEdit.getSubmitProc();
7407
                        var selection = me.getView().getSelectionModel().getSelection()[0];
7408
                        if (submit_ == undefined) {
7409
                            submit_ = false;
7410
                        }
7411
                        if (submit_ == false) {
7412

    
7413
                            formDisplay.getForm().setValues(selection.data);
7414
                            formEdit.getForm().setValues(selection.data);
7415
                            if (layout == 'L003') {
7416
                                formDisplay.setHidden(false);
7417
                                Ext.ComponentQuery.query('[name=MinovaGridFormGrid' + this.tableName + ']')[0].setHidden(true);
7418
                                var heigh = pnl.getLastheightform();
7419

    
7420
                                var pDetail = Ext.ComponentQuery.query('[name=PanelMdDetail]')[0]
7421
                                if (pDetail) {
7422
                                    pDetail.setHeight(heigh + 100);
7423
                                } else {
7424
                                    pDetail = Ext.ComponentQuery.query('[name=PanelOrmMdDetail]')[0];
7425
                                    var mainPnl_ = Ext.ComponentQuery.query('[name=MinovaORMDetail]')[0]
7426
                                    var mainPnl = mainPnl_.getHeight();
7427
                                    //pDetail.setHeight(mainPnl + 100);
7428

    
7429
                                }
7430
                            } else {
7431
                                formDisplay.setTitle("View")
7432
                                formEdit.setTitle("Edit")
7433
                            }
7434
                        } else {
7435
                            alert('still process')
7436
                        }
7437

    
7438
                    },
7439
                    beforeedit: function () {
7440
                        return false;
7441
                    }
7442
                }
7443
            }, {
7444
                xtype: 'minovaform',
7445
                name: "MinovaGridFormDisplay" + tableName,
7446
                tableName: tableName, // nama tabel /dataset
7447
                isLookup: '', // 1 or 'Y' for lookup
7448
                isDisplay: true, // true== form is displayfield
7449
                buttons: [{
7450
                    text: 'Edit',
7451
                    name: 'Edit' + tableName,
7452
                    iconCls: 'fa-edit',
7453
                    style: 'font-family: FontAwesome',
7454
                    handler: function () {
7455

    
7456
                        f = this.up().up();
7457
                        f.setSubmitProc(false);
7458
                        f.setHidden(true);
7459
                        //f.setActionSubmit(1);
7460
                        Ext.ComponentQuery.query('[name=MinovaGridFormDisplay' + f.tableName + ']')[0].setHidden(true);
7461
                        var formEdit = Ext.ComponentQuery.query('[name=MinovaGridFormEdit' + f.tableName + ']')[0];
7462
                        formEdit.setSubmitProc(true);
7463
                        formEdit.setHidden(false);
7464
                        formEdit.setActionSubmit(1);
7465
                        var p = Ext.ComponentQuery.query('[name=DetailMD]')[0];
7466
                        if (p) {
7467
                            var pnl = Ext.ComponentQuery.query('[name=MinovaMdDetail]')[0];
7468
                            var lastTitile = p.getTitle();
7469
                            pnl.setLastTitle(lastTitile);
7470
                            p.setTitle('Edit - ' + lastTitile)
7471

    
7472
                        }
7473

    
7474
                    }
7475
                }, {
7476
                    text: 'Back to Grid',
7477
                    name: 'Edit' + tableName,
7478
                    iconCls: 'fa-reply',
7479
                    style: 'font-family: FontAwesome',
7480
                    handler: function () {
7481
                        var layout = null;
7482
                        var pnl = Ext.ComponentQuery.query('[name=MinovaMdDetail]')[0];
7483
                        if (pnl) {
7484
                            layout = pnl.getLayoutType();
7485

    
7486
                        }
7487

    
7488
                        f = this.up().up();
7489
                        f.setSubmitProc(false);
7490
                        f.setHidden(true);
7491
                        Ext.ComponentQuery.query('[name=MinovaGridFormDisplay' + f.tableName + ']')[0].setHidden(false);
7492
                        Ext.ComponentQuery.query('[name=MinovaGridFormEdit' + f.tableName + ']')[0].setHidden(true);
7493

    
7494
                        if (layout == 'L003') {
7495
                            var grid_ = Ext.ComponentQuery.query('[name=MinovaGridFormGrid' + f.tableName + ']')[0];
7496
                            grid_.setHidden(false);
7497
                            Ext.ComponentQuery.query('[name=MinovaGridFormDisplay' + f.tableName + ']')[0].setHidden(true);
7498
                            Ext.ComponentQuery.query('[name=PanelMdDetail]')[0].setHeight(grid_.getHeight() + 100)
7499
                        }
7500
                    }
7501
                }
7502
                ],
7503
            }, {
7504
                xtype: 'minovaform',
7505
                name: "MinovaGridFormEdit" + tableName,
7506
                tableName: tableName, // nama tabel /dataset
7507
                isLookup: '', // 1 or 'Y' for lookup
7508
                isDisplay: false, // true== form is displayfield
7509
                buttons: [{
7510
                    text: 'Save',
7511
                    name: 'btnSaveMD',
7512
                    name: 'Save' + tableName,
7513
                    iconCls: 'fa-save',
7514
                    style: 'font-family: FontAwesome',
7515
                    handler: function () {
7516
                        f = this.up().up();
7517
                        var formEdit = Ext.ComponentQuery.query('[name=MinovaGridFormEdit' + f.tableName + ']')[0];
7518

    
7519
                        if (formEdit.getForm().isValid()) {
7520

    
7521
                            if (Ext.ComponentQuery.query('[name=MinovaORMDetail]')[0]) {
7522
                                var action_ = formEdit.getActionSubmit();
7523
                                var main_ = Ext.ComponentQuery.query('[name=mainORM]')[0];
7524
                                var record = main_.getRecordSelect();
7525

    
7526
                                if (record == undefined) {
7527
                                    var treeDetail = Ext.ComponentQuery.query('[name=treeDetail]')[0];
7528
                                    treeDetail.getSelectionModel().select(0);
7529
                                    record = treeDetail.getView().getSelectionModel().getSelection()[0];
7530

    
7531
                                }
7532
                                var frmValue = formEdit.getValues();
7533
                                var InitStartDate = 'InitStartDate';
7534
                                var InitStartDateValue = record.get('StartDate');
7535
                                frmValue[InitStartDate] = InitStartDateValue;
7536

    
7537
                                var InitEndDate = 'InitEndDate';
7538
                                var InitEndDateValue = record.get('EndDate');
7539
                                frmValue[InitEndDate] = InitEndDateValue;
7540

    
7541
                                var InitParentObject = 'InitParentObject';
7542
                                var InitParentObjectValue = record.get('ObjectId');
7543
                                if (InitParentObjectValue == undefined) {
7544
                                    InitParentObjectValue = "";
7545
                                }
7546
                                frmValue[InitParentObject] = InitParentObjectValue;
7547

    
7548
                                var InitParentClass = 'InitParentClass';
7549
                                var InitParentClassValue = record.get('ObjectType');
7550
                                if (InitParentClassValue == undefined) {
7551
                                    InitParentClassValue = "";
7552
                                }
7553
                                frmValue[InitParentClass] = InitParentClassValue;
7554
                                var frmValue_ = Ext.encode(frmValue);
7555

    
7556
                                Ext.Ajax.request({
7557
                                    method: 'POST',
7558
                                    url: '/Devt/SaveMaintainORM',
7559
                                    params: {
7560
                                        tableName: f.tableName,
7561
                                        data: frmValue_,
7562
                                        action: action_,
7563
                                        /*
7564
                                        InitStartDate: InitStartDate,
7565
                                        InitEndaDate: InitEndaDate,
7566
                                        InitParentObject: InitParentObject,
7567
                                        InitParentClass: InitParentClass
7568
                                         */
7569
                                    },
7570
                                    waitMsg: 'Saving Data...',
7571
                                    success: function (response) {
7572
                                        var result = Ext.decode(response.responseText);
7573
                                        if (result.success) {
7574
                                            MinovaMessage('Not Null', '000006', '', 'S')
7575

    
7576
                                            var pnl = Ext.ComponentQuery.query('[name=MinovaORMDetail]')[0];
7577
                                            if (pnl) {
7578
                                                Ext.ComponentQuery.query('[name=PanelOrmMdDetail]')[0].setHeight(394);
7579
                                                layout = pnl.getLayoutType();
7580
                                                pnl.setLastpage(undefined);
7581
                                                var last = 'MinovaGridFormGrid' + f.tableName;
7582
                                                var grid_ = Ext.ComponentQuery.query('[name=' + last + ']')[0]
7583

    
7584
                                                var formEdit = Ext.ComponentQuery.query('[name=MinovaGridFormEdit' + f.tableName + ']')[0];
7585
                                                formEdit.setSubmitProc(false);
7586
                                                formEdit.setHidden(true);
7587
                                                grid_.setHidden(false);
7588
                                                grid_.getStore().reload()
7589

    
7590
                                            }
7591
                                            if (layout == 'L003') {
7592
                                                var grid_ = Ext.ComponentQuery.query('[name=MinovaGridFormGrid' + f.tableName + ']')[0];
7593
                                                grid_.setHidden(false);
7594
                                                Ext.ComponentQuery.query('[name=MinovaGridFormDisplay' + f.tableName + ']')[0].setHidden(true);
7595
                                                var detail = Ext.ComponentQuery.query('[name=PanelMdDetail]')[0]
7596
                                                if (detail) {
7597
                                                    detail.setHeight(grid_.getHeight() + 100)
7598
                                                } else {
7599
                                                    var p = Ext.ComponentQuery.query('[name=MinovaORMDetail]')[0];
7600
                                                    var p_ = Ext.ComponentQuery.query('[name=DetailMD]')[0];
7601
                                                    p_.setTitle(p.getLastTitle());
7602
                                                }
7603

    
7604
                                            }
7605

    
7606
                                        } else {
7607
                                            MinovaMessage('Not Null', '000005', result.message.text, 'E')
7608
                                        }
7609
                                        var grid = Ext.ComponentQuery.query('[name=gridMenuMDOrm]')[0];
7610
                                        var s = grid.getStore();
7611
                                        s.removeAll();
7612
                                        var ObjectType = getParam("ObjectType");
7613
                                        var Lang = null;
7614
                                        Ext.Ajax.request({
7615
                                            async: false,
7616
                                            method: 'POST',
7617
                                            url: '/Devt/GetLangID',
7618
                                            success: function (response) {
7619
                                                Lang = response.responseText;
7620
                                            }
7621
                                        });
7622
                                        Ext.Ajax.request({
7623
                                            async: true,
7624
                                            method: 'POST',
7625
                                            url: '/UserControl/GetStore',
7626
                                            params: {
7627
                                                tableName: 'PHRCM0006',
7628
                                                param: 'Language[equal]' + Lang + ',ObjectClass[equal]' + ObjectType
7629

    
7630
                                            },
7631
                                            success: function (response) {
7632
                                                var results = Ext.decode(response.responseText);
7633
                                                var data_ = results.data;
7634
                                                s.loadData(results.data);
7635
                                                // console.log(data_)
7636
                                            }
7637
                                        });
7638
                                    },
7639
                                    failure: function (response) {
7640
                                        var result = Ext.decode(response.responseText);
7641
                                        console.log(result);
7642
                                    }
7643
                                });
7644
                            } else {
7645
                                var frmValue = Ext.encode(formEdit.getValues());
7646
                                Ext.Ajax.request({
7647
                                    method: 'POST',
7648
                                    url: '/Devt/SaveTable',
7649
                                    params: {
7650
                                        tableName: f.tableName,
7651
                                        data: frmValue,
7652
                                        action: formEdit.getActionSubmit()
7653
                                    },
7654
                                    waitMsg: 'Saving Data...',
7655
                                    success: function (response) {
7656
                                        var result = Ext.decode(response.responseText);
7657
                                        if (result.success) {
7658
                                            MinovaMessage('Not Null', '000006', '', 'S')
7659

    
7660
                                            var pnl = Ext.ComponentQuery.query('[name=MinovaMdDetail]')[0];
7661

    
7662
                                            if (pnl) {
7663
                                                Ext.ComponentQuery.query('[name=PanelMdDetail]')[0].setHeight(394);
7664
                                                layout = pnl.getLayoutType();
7665
                                                pnl.setLastpage(undefined);
7666
                                                var last = 'MinovaGridFormGrid' + f.tableName;
7667
                                                var grid_ = Ext.ComponentQuery.query('[name=' + last + ']')[0]
7668

    
7669
                                                var formEdit = Ext.ComponentQuery.query('[name=MinovaGridFormEdit' + f.tableName + ']')[0];
7670
                                                formEdit.setSubmitProc(false);
7671
                                                formEdit.setHidden(true);
7672
                                                grid_.setHidden(false);
7673
                                                grid_.getStore().reload()
7674
                                                var mpnl = Ext.ComponentQuery.query('[name=DetailMD]')[0]
7675
                                                mpnl.setTitle(pnl.getLastTitle());
7676

    
7677
                                            }
7678
                                            if (layout == 'L003') {
7679
                                                var grid_ = Ext.ComponentQuery.query('[name=MinovaGridFormGrid' + f.tableName + ']')[0];
7680
                                                grid_.setHidden(false);
7681
                                                Ext.ComponentQuery.query('[name=MinovaGridFormDisplay' + f.tableName + ']')[0].setHidden(true);
7682
                                                Ext.ComponentQuery.query('[name=PanelMdDetail]')[0].setHeight(grid_.getHeight() + 100)
7683
                                            }
7684

    
7685
                                        } else {
7686
                                            MinovaMessage('Not Null', '000005', result.message.text, 'E')
7687
                                        }
7688
                                    },
7689
                                    failure: function (response) {
7690
                                        var result = Ext.decode(response.responseText);
7691
                                        //console.log(result);
7692
                                    }
7693
                                });
7694
                            }
7695

    
7696
                        }
7697
                    }
7698
                }, {
7699
                    text: 'Delete',
7700
                    iconCls: 'fa-trash-o',
7701
                    name: 'Delete',
7702
                    style: 'font-family: FontAwesome',
7703
                    action: 'CRUDdelete',
7704
                    handler: function () {
7705
                        //add fungsi Delete
7706
                        f = this.up().up();
7707
                        var formEdit = Ext.ComponentQuery.query('[name=MinovaGridFormEdit' + f.tableName + ']')[0];
7708
                        var frmValue = Ext.encode(formEdit.getValues());
7709
                        if (formEdit.getForm().isValid()) {
7710
                            Ext.Ajax.request({
7711
                                method: 'POST',
7712
                                url: '/Devt/SaveTable',
7713
                                params: {
7714
                                    tableName: f.tableName,
7715
                                    data: frmValue,
7716
                                    action: 2
7717
                                },
7718
                                waitMsg: 'Saving Data...',
7719
                                success: function (response) {
7720
                                    var result = Ext.decode(response.responseText);
7721
                                    if (result.success) {
7722
                                        MinovaMessage('Not Null', '000006', '', 'S')
7723

    
7724
                                        var pnl = Ext.ComponentQuery.query('[name=MinovaMdDetail]')[0];
7725
                                        if (pnl) {
7726
                                            layout = pnl.getLayoutType();
7727
                                            pnl.setLastpage(undefined);
7728

    
7729
                                        }
7730
                                        if (layout == 'L003') {
7731
                                            var grid_ = Ext.ComponentQuery.query('[name=MinovaGridFormGrid' + f.tableName + ']')[0];
7732
                                            grid_.setHidden(false);
7733
                                            Ext.ComponentQuery.query('[name=MinovaGridFormDisplay' + f.tableName + ']')[0].setHidden(true);
7734
                                            Ext.ComponentQuery.query('[name=PanelMdDetail]')[0].setHeight(grid_.getHeight() + 100)
7735
                                        }
7736

    
7737
                                    } else {
7738
                                        MinovaMessage('Not Null', '000005', result.message.text, 'E')
7739
                                    }
7740
                                },
7741
                                failure: function (response) {
7742
                                    var result = Ext.decode(response.responseText);
7743
                                    //console.log(result);
7744
                                }
7745
                            });
7746
                        }
7747
                    }
7748

    
7749
                }, {
7750
                    text: 'Cancel',
7751
                    iconCls: 'fa-reply',
7752
                    style: 'font-family: FontAwesome',
7753
                    handler: function () {
7754
                        f = this.up().up();
7755
                        f.setSubmitProc(false);
7756
                        f.setHidden(true);
7757
                        var pnl = Ext.ComponentQuery.query('[name=MinovaMdDetail]')[0];
7758

    
7759
                        if (pnl) {
7760
                            //'L001'=grid L002 =heder detail L003=card L004=custom
7761
                            layout = pnl.getLayoutType();
7762
                            var last = 'MinovaGridFormGrid' + f.tableName;
7763
                            var grid_ = Ext.ComponentQuery.query('[name=' + last + ']')[0];
7764
                            grid_.setHidden(false);
7765
                            pnl.setLastpage(undefined);
7766
                            var mpnl = Ext.ComponentQuery.query('[name=DetailMD]')[0]
7767
                            mpnl.setTitle(pnl.getLastTitle());
7768
                            if (layout == 'L003') {
7769
                                Ext.ComponentQuery.query('[name=PanelMdDetail]')[0].setHeight(400);
7770
                            } else {
7771
                                Ext.ComponentQuery.query('[name=MinovaGridFormDisplay' + f.tableName + ']')[0].setHidden(false);
7772
                            }
7773
                        } else {
7774
                            // Ext.ComponentQuery.query('[name=MinovaGridFormDisplay' + f.tableName + ']')[0].setHidden(false);
7775
                            var mdDetail = Ext.ComponentQuery.query('[name=MinovaORMDetail]')[0];
7776
                            layout = mdDetail.getLayoutType();
7777
                            if (layout == 'L003') {
7778
                                var panelDetail = Ext.ComponentQuery.query('[name=PanelOrmMdDetail]')[0];
7779
                                Ext.ComponentQuery.query('[name=MinovaGridFormGrid' + tableName + ']')[0].setHidden(false)
7780

    
7781
                                panelDetail.setHeight(400);
7782
                            } else {
7783
                                Ext.ComponentQuery.query('[name=MinovaGridFormDisplay' + f.tableName + ']')[0].setHidden(false);
7784
                            }
7785
                        }
7786

    
7787
                    }
7788
                }
7789
                ],
7790
            }
7791
            ]
7792
        });
7793
        me.callParent(arguments);
7794
    }
7795
});
7796

    
7797
Ext.define('MinovaUtil.MinovaES.MinovaGridCard', {
7798
    extend: 'Ext.form.Panel',
7799
    alias: ['widget.minovagridcard', 'widget.MinovaGridCard'],
7800
    tableName: undefined, //nama tabel
7801
    param: undefined, //param query
7802
    //hidebutton: undefined,
7803
    pagesize: undefined,
7804
    storename: undefined,
7805
    titleform: undefined,
7806
    titlegrid: undefined,
7807
    heightgrid: undefined,
7808
    heightform: undefined,
7809
    iseditform: undefined,
7810

    
7811
    getIsEditform: function () {
7812
        return this.iseditform;
7813
    },
7814
    setIsEditform: function (value) {
7815
        var me = this;
7816
        me.iseditform = value;
7817
        return me;
7818
    },
7819
    initComponent: function () {
7820
        var me = this;
7821
        var storename = me.storename;
7822
        if (storename == "" || storename == undefined) {
7823
            storename = "store" + me.tableName;
7824
        }
7825
        var tableName = me.tableName;
7826
        Ext.applyIf(me, {
7827
            items: [{
7828
                layoutType: "MinovaGridCard",
7829
                //title: me.titlegrid,
7830
                xtype: "minovagrid",
7831
                tableName: tableName, // nama tebel/dataset
7832
                name: "MinovaGridCardGrid" + tableName, //name bebeas
7833
                param: me.param, // parameter filteran
7834
                pagesize: me.pagesize, // jumlah record yang muncul per page
7835
                storename: storename, //nama store bebas
7836
                isLookup: me.isLookup, // apakah grid untuk look up? jika ya isi dengan 1 atau 'Y' kalau bukan isi string kosong
7837
                height: 330,
7838
                bodyPadding: 0,
7839
                dockedItems: [{
7840
                    xtype: 'pagingtoolbar',
7841
                    store: storename, // harus sama dengan naa store diatas
7842
                    dock: 'bottom', //posisi paging
7843
                    pageSize: me.pagesize,
7844
                    displayInfo: true
7845
                }
7846
                ],
7847

    
7848
                listeners: {
7849
                    viewready: function () {
7850
                        if (MinovaUtil.GetActionMenu() == 0 || MinovaUtil.GetActionMenu() == undefined || MinovaUtil.GetActionMenu() == "") {
7851
                            Ext.ComponentQuery.query('[name=actionBtn]')[0].setHidden(true)
7852
                            Ext.ComponentQuery.query('[name=Edit' + me.tableName + ']')[0].setHidden(true)
7853
                        } else {
7854
                            Ext.ComponentQuery.query('[name=actionBtn]')[0].setHidden(false)
7855
                            //Ext.ComponentQuery.query('[name=Edit_]')[0].setHidden(true)
7856
                            Ext.ComponentQuery.query('[name=Delete_]')[0].setHidden(true)
7857
                            Ext.ComponentQuery.query('[name=Edit' + me.tableName + ']')[0].setHidden(false)
7858
                        }
7859
                        //case orm
7860
                        if (this.layoutType == "MinovaGridCard") {
7861
                            var formDisplay = Ext.ComponentQuery.query('[name=MinovaGridCardDisplay' + this.tableName + ']')[0];
7862
                            var formEdit = Ext.ComponentQuery.query('[name=MinovaGridCardEdit' + this.tableName + ']')[0];
7863
                            formDisplay.setHidden(true);
7864
                            formEdit.setHidden(true);
7865
                        } else if (this.layoutType == "MinovaGridForm") {
7866
                            var formEdit = Ext.ComponentQuery.query('[name=MinovaGridCardEdit' + this.tableName + ']')[0];
7867
                            formEdit.setHidden(true);
7868
                        } else {
7869
                            var formDisplay = Ext.ComponentQuery.query('[name=MinovaGridCardDisplay' + this.tableName + ']')[0];
7870
                            var formEdit = Ext.ComponentQuery.query('[name=MinovaGridCardEdit' + this.tableName + ']')[0];
7871
                            formDisplay.setHidden(true);
7872
                            formEdit.setHidden(true);
7873
                        }
7874

    
7875
                    },
7876
                    itemdblclick: function () {
7877
                        //alert('a')
7878
                        var me = this;
7879

    
7880
                        var formDisplay = undefined;
7881
                        var formEdit = undefined;
7882
                        //case md orm
7883

    
7884
                        if (this.layoutType == "MinovaGridCard") {
7885
                            formDisplay = Ext.ComponentQuery.query('[name=MinovaGridCardDisplay' + this.tableName + ']')[0];
7886
                            formEdit = Ext.ComponentQuery.query('[name=MinovaGridCardEdit' + this.tableName + ']')[0];
7887
                        } else if (this.layoutType == "MinovaGridForm") {
7888
                            formDisplay = Ext.ComponentQuery.query('[name=MinovaGridCardDisplay' + this.tableName + ']')[0];
7889
                            formEdit = Ext.ComponentQuery.query('[name=MinovaGridCardEdit' + this.tableName + ']')[0];
7890
                            // formDisplay.setHidden(true);
7891

    
7892
                        } else {
7893
                            formDisplay = Ext.ComponentQuery.query('[name=MinovaGridCardDisplay' + this.tableName + ']')[0];
7894
                            formEdit = Ext.ComponentQuery.query('[name=MinovaGridCardEdit' + this.tableName + ']')[0];
7895

    
7896
                        }
7897
                        var submit_ = formEdit.getSubmitProc();
7898
                        var selection = me.getView().getSelectionModel().getSelection()[0];
7899
                        if (submit_ == undefined) {
7900
                            submit_ = false;
7901
                        }
7902
                        if (submit_ == false) {
7903

    
7904
                            if (this.layoutType == "MinovaGridCard") {
7905

    
7906
                                formDisplay.getForm().setValues(selection.data);
7907
                                formEdit.getForm().setValues(selection.data);
7908
                                formDisplay.setHidden(false);
7909
                                formEdit.setHidden(true);
7910
                                this.setHidden(true);
7911
                            } else if (this.layoutType == "MinovaGridForm") {
7912
                                formEdit.setHidden(true);
7913
                                formDisplay.getForm().setValues(selection.data);
7914
                                formEdit.getForm().setValues(selection.data);
7915
                            } else {
7916
                                formDisplay.setHidden(true);
7917
                                formEdit.setHidden(true);
7918

    
7919
                                formDisplay.getForm().setValues(selection.data);
7920
                                formEdit.getForm().setValues(selection.data);
7921
                            }
7922
                            // untuk case ORM
7923
                            var display_ = Ext.ComponentQuery.query('[name=MinovaGridCardDisplay' + tableName + ']')[0].getHeight();
7924
                            if (display_) {
7925
                                var pnlORM = Ext.ComponentQuery.query('[name=PanelOrmMdDetail]')[0]
7926
                                var pnlMD = Ext.ComponentQuery.query('[name=PanelMdDetail]')[0]
7927
                                if (pnlORM) {
7928
                                    pnlORM.setHeight(pnl + 100);
7929
                                }
7930
                                if (pnlMD) {
7931
                                    Ext.ComponentQuery.query('[name=MinovaMdDetail]')[0].setHeight(pnlMD + 600);
7932
                                    Ext.ComponentQuery.query('[name=PanelMdDetail]')[0].setHeight(pnlMD + 600);
7933
                                }
7934
                            }
7935
                            //end case ORM and MD
7936
                        } else {
7937
                            alert('still process')
7938
                        }
7939

    
7940
                    },
7941
                    beforeedit: function () {
7942
                        return false;
7943
                    }
7944
                }
7945
            }, {
7946
                xtype: 'minovaform',
7947
                name: "MinovaGridCardDisplay" + tableName,
7948
                tableName: tableName, // nama tabel /dataset
7949
                isLookup: '', // 1 or 'Y' for lookup
7950
                isDisplay: true, // true== form is displayfield
7951
                buttons: [{
7952
                    text: 'Edit',
7953
                    name: 'Edit' + tableName,
7954
                    iconCls: 'fa-edit',
7955
                    style: 'font-family: FontAwesome',
7956
                    handler: function () {
7957
                        f = this.up().up();
7958
                        f.setSubmitProc(false);
7959
                        f.setHidden(true);
7960
                        var formDisplay = Ext.ComponentQuery.query('[name=MinovaGridCardDisplay' + f.tableName + ']')[0].setHidden(true);
7961
                        Ext.ComponentQuery.query('[name=MinovaGridCardGrid' + f.tableName + ']')[0].setHidden(true);
7962
                        Ext.ComponentQuery.query('[name=MinovaGridCardEdit' + f.tableName + ']')[0].setHidden(false);
7963

    
7964
                    }
7965
                }, {
7966
                    text: 'Back to Grid',
7967
                    name: 'Cancel' + tableName,
7968
                    iconCls: 'fa-reply',
7969
                    style: 'font-family: FontAwesome',
7970
                    handler: function () {
7971
                        f = this.up().up();
7972
                        f.setSubmitProc(false);
7973
                        f.setHidden(true);
7974
                        var formDisplay = Ext.ComponentQuery.query('[name=MinovaGridCardDisplay' + f.tableName + ']')[0].setHidden(true);
7975
                        Ext.ComponentQuery.query('[name=MinovaGridCardGrid' + f.tableName + ']')[0].setHidden(false);
7976
                        Ext.ComponentQuery.query('[name=MinovaGridCardEdit' + f.tableName + ']')[0].setHidden(true);
7977

    
7978
                    }
7979
                }
7980
                ],
7981
            }, {
7982
                xtype: 'minovaform',
7983
                name: "MinovaGridCardEdit" + tableName,
7984
                tableName: tableName, // nama tabel /dataset
7985
                isLookup: '', // 1 or 'Y' for lookup
7986
                isDisplay: false, // true== form is displayfield
7987
                buttons: [{
7988
                    text: 'Save',
7989
                    name: 'Save' + tableName,
7990
                    iconCls: 'fa-save',
7991
                    style: 'font-family: FontAwesome',
7992
                    handler: function () {
7993
                        f = this.up().up();
7994
                        var formEdit = Ext.ComponentQuery.query('[name=MinovaGridCardEdit' + f.tableName + ']')[0];
7995
                    }
7996
                }, {
7997
                    text: 'Delete',
7998
                    iconCls: 'fa-trash-o',
7999
                    name: 'Delete',
8000
                    style: 'font-family: FontAwesome',
8001
                    action: 'CRUDdelete'
8002
                }, {
8003
                    text: 'Back to Grid',
8004
                    name: 'EditForm' + tableName,
8005
                    iconCls: 'fa-reply',
8006
                    style: 'font-family: FontAwesome',
8007
                    handler: function () {
8008
                        f = this.up().up();
8009
                        f.setSubmitProc(false);
8010
                        f.setHidden(true);
8011
                        var formDisplay = Ext.ComponentQuery.query('[name=MinovaGridCardDisplay' + f.tableName + ']')[0].setHidden(true);
8012
                        Ext.ComponentQuery.query('[name=MinovaGridCardGrid' + f.tableName + ']')[0].setHidden(false);
8013
                        Ext.ComponentQuery.query('[name=MinovaGridCardEdit' + f.tableName + ']')[0].setHidden(true);
8014

    
8015
                    }
8016
                }
8017
                ],
8018
            }
8019
            ]
8020
        });
8021
        me.callParent(arguments);
8022
    }
8023
});
8024

    
8025
Ext.define('MinovaUtil.MinovaES.MinovaFloatField', {
8026
    extend: 'Ext.form.field.Number',
8027
    alias: 'widget.minovafloatfield',
8028
    hideTrigger: true,
8029
    allowDecimals: true,
8030
    precision: undefined,
8031
    isValid: function () {
8032
        var b = this,
8033
		a = b.disabled,
8034
		c = b.forceValidation || !a;
8035
        return c ? b.validateValue(b.processRawValue(b.getValue())) : a
8036
    },
8037
    setValue: function (v) {
8038
        this.setRawValue(this.getFormattedValue(v));
8039
    },
8040
    getValue: function () {
8041
        var val = this.removeFormat(this.getRawValue());
8042
        this.value = val;
8043
        return val;
8044
    },
8045
    getSubmitValue: function () {
8046
        return this.removeFormat(this.getRawValue());
8047
    },
8048
    removeFormat: function (v) {
8049
        if (Ext.isEmpty(v))
8050
            return v;
8051
        else {
8052
            v = v.replace(Ext.util.Format.currencySign, '');
8053
            v = v.replace(new RegExp('[' + Ext.util.Format.thousandSeparator + ']', 'g'), '');
8054
            return v;
8055
        }
8056
    },
8057
    onFocus: function () {
8058
        this.setRawValue(this.removeFormat(this.getRawValue()));
8059
    },
8060
    onBlur: function () {
8061
        this.setRawValue(this.getFormattedValue(this.getValue()));
8062
    },
8063
    getFormattedValue: function (v) {
8064
        var prec = '';
8065
        if (this.precision != '' && this.precision > 0) {
8066
            for (var i = 0; i < this.precision; i++) {
8067
                prec = prec + '0'
8068
            }
8069
        }
8070
        return Ext.util.Format.number(v, '0,000.' + prec);
8071
    }
8072
});
8073
Ext.define('MinovaUtil.MinovaES.MinovaNumberField', {
8074
    extend: 'Ext.form.field.Number',
8075
    alias: 'widget.minovanumberfield',
8076
    //hideTrigger: true,
8077
    isValid: function () {
8078
        var b = this,
8079
		a = b.disabled,
8080
		c = b.forceValidation || !a;
8081
        return c ? b.validateValue(b.processRawValue(b.getValue())) : a
8082
    },
8083
    setValue: function (v) {
8084
        this.setRawValue(this.getFormattedValue(v));
8085
    },
8086
    getValue: function () {
8087
        var val = this.removeFormat(this.getRawValue());
8088
        this.value = val;
8089
        return val;
8090
    },
8091
    getSubmitValue: function () {
8092
        return this.removeFormat(this.getRawValue());
8093
    },
8094
    removeFormat: function (v) {
8095
        if (Ext.isEmpty(v))
8096
            return v;
8097
        else {
8098
            v = v.replace(Ext.util.Format.currencySign, '');
8099
            v = v.replace(new RegExp('[' + Ext.util.Format.thousandSeparator + ']', 'g'), '');
8100
            return v;
8101
        }
8102
    },
8103
    onFocus: function () {
8104
        this.setRawValue(this.removeFormat(this.getRawValue()));
8105
    },
8106
    onBlur: function () {
8107
        this.setRawValue(this.getFormattedValue(this.getValue()));
8108
    },
8109
    getFormattedValue: function (v) {
8110
        return Ext.util.Format.number(v, '0,000');
8111
    }
8112
});
8113

    
8114
Ext.define('MinovaUtil.MinovaES.SysDateTime', {
8115
    extend: 'Ext.form.field.Text',
8116
    alias: ['widget.minovasysdatetime'],
8117
    undefinedText: '&#160;',
8118
    setValue: function (v) {
8119
        var value = v;
8120
        var hasil = null;
8121
        /*
8122
		if (value === undefined) {
8123
		return this.undefinedText;
8124
		}
8125
		if (value === null) {
8126
		return this.setRawValue(null);
8127
		}
8128
		 */
8129
        //hamid 200916
8130
        //if (value != null || value != "" || value != undefined) {
8131
        //    return this.setRawValue(null);
8132
        if (value == "" || value == null) {
8133
            return this.setRawValue("");
8134
            //end
8135
        } else {
8136
            var d = value.substring(6, 8);
8137
            var m = value.substring(4, 6);
8138
            var y = value.substring(0, 4);
8139
            var h = value.substring(8, 10);
8140
            var mt = value.substring(10, 12);
8141
            var s = value.substring(12, 14);
8142
            hasil = d + '/' + m + '/' + y + '  ' + '  ' + h + ':' + mt + ':' + s;
8143
        }
8144

    
8145
        this.setRawValue(hasil);
8146
    },
8147
    getRawValue: function () {
8148
        return this.getValue();
8149
    },
8150
    getValue: function () {
8151
        var value = this.rawValue;
8152
        var hasil = null;
8153
        if (value != undefined) {
8154
            var d = value.substring(0, 2);
8155
            var m = value.substring(3, 5);
8156
            var y = value.substring(6, 10);
8157
            var h = value.substring(14, 16);
8158
            var mt = value.substring(17, 19);
8159
            var s = value.substring(20, 22);
8160
            hasil = y + m + d + h + mt + s;
8161
        }
8162
        return hasil;
8163
    }
8164
});
8165
Ext.define('MinovaUtil.MinovaES.MinovaDateTime', {
8166
    extend: 'Ext.form.field.Trigger',
8167
    alias: ['widget.minovadatetime', 'widget.MinovaDateTime'],
8168
    tableName: undefined,
8169
    param: undefined,
8170
    anchor: '50%',
8171
    initComponent: function () {
8172
        var me = this;
8173
        Ext.applyIf(me, {});
8174
        me.callParent(arguments);
8175
    },
8176
    onTriggerClick: function () {
8177
        Ext.create('Ext.window.Window', {
8178
            title: 'Hello',
8179
            modal: true,
8180
            layout: 'fit',
8181
            dockedItems: [{
8182
                xtype: 'toolbar',
8183
                dock: 'bottom',
8184
                align: 'center',
8185
                items: [{
8186
                    xtype: 'tbspacer'
8187
                }, {
8188
                    xtype: 'button',
8189
                    text: 'Today'
8190
                }, {
8191
                    xtype: 'tbspacer'
8192
                }, ]
8193
            }
8194
            ],
8195
            items: [{
8196
                xtype: 'panel',
8197
                layout: 'hbox',
8198
                items: [{
8199
                    xtype: 'datepicker',
8200
                    name: 'date',
8201
                    showToday: false,
8202
                    handler: function (picker, date) {}
8203

    
8204
                }, {
8205
                    xtype: 'sliderfield',
8206
                    width: 60,
8207
                    name: 'hour',
8208
                    labelAlign: 'top',
8209
                    fieldLabel: 'Hour',
8210
                    value: 0,
8211
                    increment: 1,
8212
                    minValue: 0,
8213
                    maxValue: 24,
8214
                    margin: '10 5 3 20',
8215
                    renderTo: Ext.getBody(),
8216
                }, {
8217
                    xtype: 'sliderfield',
8218
                    width: 60,
8219
                    name: 'minute',
8220
                    labelAlign: 'top',
8221
                    fieldLabel: 'Minute',
8222
                    value: 0,
8223
                    increment: 1,
8224
                    minValue: 0,
8225
                    maxValue: 60,
8226
                    margin: '10 5 3 20',
8227
                    renderTo: Ext.getBody(),
8228
                }, {
8229
                    xtype: 'sliderfield',
8230
                    width: 60,
8231
                    name: 'second',
8232
                    labelAlign: 'top',
8233
                    fieldLabel: 'Second',
8234
                    value: 0,
8235
                    increment: 1,
8236
                    minValue: 0,
8237
                    maxValue: 60,
8238
                    margin: '10 5 3 20',
8239
                    renderTo: Ext.getBody(),
8240
                }
8241
                ]
8242
            }
8243
            ]
8244
        }).show();
8245
    }
8246
});
8247

    
8248
Ext.define('MinovaUtil.MinovaES.MinovaMDORM', {
8249
    extend: 'Ext.form.Panel',
8250
    alias: ['widget.minovamdorm'],
8251

    
8252
    //controller: 'sample',
8253
    controller: 'orm-manage-controller',
8254
    tableName: undefined, //nama tabel
8255
    param: undefined, //param query
8256
    pagesize: undefined,
8257
    storename: undefined,
8258
    titleform: undefined,
8259
    titlegrid: undefined,
8260
    heightgrid: undefined,
8261
    heightform: undefined,
8262
    iseditform: undefined,
8263
    lastheightform: undefined,
8264
    layoutType: undefined,
8265
    lastpage: undefined,
8266
    lastTitle: undefined,
8267
    getLastTitle: function () {
8268
        return this.lastTitle;
8269
    },
8270
    setLastTitle: function (value) {
8271
        var me = this;
8272
        me.lastTitle = value;
8273
        return me;
8274
    },
8275
    getLastpage: function () {
8276
        return this.lastpage;
8277
    },
8278
    setLastpage: function (value) {
8279
        var me = this;
8280
        me.lastpage = value;
8281
        return me;
8282
    },
8283
    getLayoutType: function () {
8284
        return this.layoutType;
8285
    },
8286
    setLayoutType: function (value) {
8287
        var me = this;
8288
        me.layoutType = value;
8289
        return me;
8290
    },
8291
    getLastheightform: function () {
8292
        return this.lastheightform;
8293
    },
8294
    setLastheightform: function (value) {
8295
        var me = this;
8296
        me.lastheightform = value;
8297
        return me;
8298
    },
8299

    
8300
    getIsEditform: function () {
8301
        return this.iseditform;
8302
    },
8303
    setIsEditform: function (value) {
8304
        var me = this;
8305
        me.iseditform = value;
8306
        return me;
8307
    },
8308
    initComponent: function () {
8309
        var me = this;
8310
        var userAction = MinovaUtil.GetActionMenu();
8311
        var crudBtn = true;
8312
        if (userAction == '1') {
8313
            crudBtn = false
8314
        }
8315
        var storename = me.storename;
8316
        if (storename == "" || storename == undefined) {
8317
            storename = "store" + me.tableName;
8318
        }
8319
        var tableName = me.tableName;
8320
        Ext.applyIf(me, {
8321
            items: [{
8322
                layoutType: "MinovaGridForm",
8323
                title: me.titlegrid,
8324
                xtype: "minovagridmd",
8325
                tableName: tableName, // nama tebel/dataset
8326
                name: "MinovaGridFormGrid", //name bebeas
8327
                param: me.param, // parameter filteran
8328
                pagesize: me.pagesize, // jumlah record yang muncul per page
8329
                storename: storename, //nama store bebas
8330
                isLookup: me.isLookup, // apakah grid untuk look up? jika ya isi dengan 1 atau 'Y' kalau bukan isi string kosong
8331
                height: 330,
8332
                bodyPadding: 0,
8333
                tbar: [{
8334
                    xtype: 'button',
8335
                    text: 'Action',
8336
                    hidden: crudBtn,
8337
                    name: 'actionGrid',
8338
                    menu: [{
8339
                        text: 'Add',
8340
                        action: 'addGrid',
8341
                        name: 'addGridORM',
8342
                        action: 'CRUDaddNewRecord',
8343
                        style: 'font-family: FontAwesome',
8344
                        itemId: 'AddData',
8345
                        iconCls: 'fa-plus-circle',
8346

    
8347
                    }, {
8348
                        text: 'Copy',
8349
                        action: 'copyGrid',
8350
                        name: 'CopyGridORM',
8351
                        iconCls: 'fa-copy',
8352
                        style: 'font-family: FontAwesome',
8353
                    }, {
8354
                        text: 'Edit',
8355
                        action: 'editGrid',
8356
                        name: 'EditGridORM',
8357
                        iconCls: 'fa-edit',
8358
                        style: 'font-family: FontAwesome',
8359
                    }, {
8360
                        text: 'Delete',
8361
                        name: 'DeleteGridORM',
8362
                        hidden: true,
8363
                        iconCls: 'fa-trash-o',
8364
                        style: 'font-family: FontAwesome',
8365
                    }
8366
                    ]
8367
                }, {
8368
                    xtype: 'tbfill'
8369
                }, {
8370
                    text: 'Clear Filters',
8371
                    tooltip: 'Clear all filters',
8372
                    name: 'clearbtn',
8373
                    handler: function () {
8374
                        var tolbar = this.up()
8375
                        var grid_ = tolbar.up()
8376
                        grid_.filters.clearFilters()
8377
                    }
8378
                }, ],
8379

    
8380
                dockedItems: [{
8381
                    xtype: 'pagingtoolbar',
8382
                    store: storename, // harus sama dengan naa store diatas
8383
                    dock: 'bottom', //posisi paging
8384
                    pageSize: me.pagesize,
8385
                    displayInfo: true
8386
                }
8387
                ],
8388
                listeners: {
8389
                    afterrender: function (me) {
8390
                        if (MinovaUtil.GetActionMenu() == "1") {}
8391
                        else {}
8392
                    },
8393

    
8394
                },
8395

    
8396
            }, {
8397
                xtype: 'minovaform',
8398
                name: "MinovaGridFormDisplay",
8399
                //name: "MinovaGridFormEdit",
8400
                border: false,
8401
                tableName: tableName, // nama tabel /dataset
8402
                isLookup: '', // 1 or 'Y' for lookup
8403
                isDisplay: true, // true== form is displayfield
8404
                /*
8405
                buttons: [{
8406
                text: 'Edit',
8407
                name: 'EditDisplay',
8408
                iconCls: 'fa-edit',
8409
                style: 'font-family: FontAwesome',
8410
                }, {
8411
                text: 'Back to Grid',
8412
                name: 'BackGrid',
8413
                iconCls: 'fa-reply',
8414
                style: 'font-family: FontAwesome',
8415
                }
8416
                ],
8417
                 */
8418
            }, {
8419
                xtype: 'minovaform',
8420
                //name: "MinovaGridFormDisplay",
8421
                name: "MinovaGridFormEdit",
8422
                border: false,
8423
                tableName: tableName, // nama tabel /dataset
8424
                isLookup: '', // 1 or 'Y' for lookup
8425
                isDisplay: false, // true== form is displayfield
8426
                /*
8427
                buttons: [{
8428
                text: 'Save',
8429
                name: 'btnSaveMD',
8430
                iconCls: 'fa-save',
8431
                style: 'font-family: FontAwesome',
8432
                }, {
8433
                text: 'Delete',
8434
                iconCls: 'fa-trash-o',
8435
                name: 'btnDeleteMD',
8436
                style: 'font-family: FontAwesome',
8437
                action: 'CRUDdelete',
8438
                }, {
8439
                text: 'Cancel',
8440
                name: 'btnCancelMD',
8441
                iconCls: 'fa-reply',
8442
                style: 'font-family: FontAwesome',
8443
                }
8444
                ],
8445
                 */
8446
            }
8447
            ]
8448

    
8449
        });
8450
        me.callParent(arguments);
8451
    }
8452
});
8453

    
8454
Ext.define('MinovaUtil.MinovaES.MinovaHeaderMD', {
8455
    extend: 'Ext.form.Panel',
8456
    alias: ['widget.MinovaHeadermd', 'widget.MinovaHeaderMD'],
8457
    allTableName: undefined,
8458
    param: undefined,
8459
    //frame: true,
8460
    resizable: true,
8461
    autoScroll: true,
8462
    minHeight: 20,
8463
    layout: 'column',
8464
    name: 'HeaderMD',
8465
    getAllTableName: function () {
8466
        return this.allTableName;
8467
    },
8468
    setAllTableName: function (value) {
8469
        var me = this;
8470
        me.allTableName = value;
8471
        return me;
8472
    },
8473
    listeners: {
8474
        afterrender: function (me) {
8475

    
8476
            var nowDate = MinovaUtil.GetNowDate()
8477
            var allTbl = me.getAllTableName();
8478
            //alert(allTbl);
8479
            var splitTable = allTbl.split(',')
8480
            splitTable.forEach(function (tbl) {
8481
                // console.log(tbl);
8482
                //set values form
8483
                var nowDate = MinovaUtil.GetNowDate();
8484
                parameter = null;
8485
                if (me.isEmployee == true) {
8486
                    parameter = 'StartDate[<=]' + nowDate + ',EndDate[>=]' + nowDate + ',EmployeeID[=]' + getParam("EmployeeID")
8487
                } else {
8488
                    parameter = 'StartDate[<=]' + nowDate + ',EndDate[>=]' + nowDate + ',EmployeeID[=]' + getParam("ApplicantID")
8489
                }
8490
                Ext.Ajax.request({
8491
                    method: 'POST',
8492
                    //async: false,
8493
                    url: '/UserControl/GetStore',
8494
                    params: {
8495
                        tableName: tbl,
8496
                        param: parameter
8497
                    },
8498
                    success: function (response) {
8499
                        var results = Ext.decode(response.responseText);
8500
                        hasil = results.data;
8501
                        //console.log(hasil)
8502
                        if (hasil.length > 0) {
8503
                            me.getForm().setValues(hasil[0]);
8504

    
8505
                            //console.log(me)
8506
                        }
8507

    
8508
                    }
8509
                });
8510
            });
8511

    
8512
            //setTimeout(function () {
8513
            //    // var me_ = Ext.ComponentQuery.query('[name=Header]')[0];
8514
            //    // me_.setTitle(me_.getTitle() + ' - ' + Ext.ComponentQuery.query('[name=FullName]')[0].getValue());
8515
            //}, 100);
8516

    
8517
        },
8518

    
8519
    },
8520

    
8521
    initComponent: function () {
8522
        var me = this;
8523
        var col1 = [];
8524
        var col2 = [];
8525
        var hasil = null;
8526
        //get moduletype
8527
        //var ModuleType = 'PA';
8528
        //var ModuleType = MinovaUtil.GetModuleType()
8529
        //get Lang
8530
        var LangId = localStorage.LangId;
8531
        var allTable = null;
8532
        var tbl = null;
8533
        var tblTemp = null;
8534
        var nowDate = MinovaUtil.GetNowDate();
8535
        //var Photo_ = 'nophoto.gif';
8536
        var Photo = 'nophoto.gif';
8537
        tableName = null;
8538
        parameter = null;
8539
        // get Photo
8540
        //hamid200916
8541
        if (me.isEmployee == true) {
8542
            tableName = 'PHRPA0001';
8543
            parameter = 'StartDate[<=]' + nowDate + ',EndDate[>=]' + nowDate + ',EmployeeID[=]' + getParam("EmployeeID");
8544
        } else {
8545
            tableName = 'PHRRC0001';
8546
            parameter = 'StartDate[<=]' + nowDate + ',EndDate[>=]' + nowDate + ',EmployeeID[=]' + getParam("ApplicantID")
8547
        }
8548
        Ext.Ajax.request({
8549
            method: 'POST',
8550
            async: false,
8551
            url: '/UserControl/GetStore',
8552
            params: {
8553
                tableName: tableName,
8554
                param: parameter
8555
            },
8556
            success: function (response) {
8557
                var results = Ext.decode(response.responseText);
8558
                hasil = results.data;
8559
                if (hasil.length > 0) {
8560
                    dataPhoto = hasil[0].Picture
8561
                    if (dataPhoto != "") {
8562
                        Photo = dataPhoto;
8563
                    }
8564
                }
8565

    
8566
            }
8567
        });
8568

    
8569
        var hasil = undefined;
8570
        Ext.Ajax.request({
8571
            async: false,
8572
            method: 'POST',
8573
            url: '/UserControl/GetStore',
8574
            params: {
8575
                tableName: 'PDSBS0009',
8576
                param: 'MenuID[=]' + MinovaUtil.GetMenuID() + ',LangId[=]' + LangId
8577
            },
8578
            success: function (response) {
8579
                hasil = Ext.decode(response.responseText).data;
8580

    
8581
            }
8582
        });
8583

    
8584
        //sorting results
8585
        hasil = hasil.sort(MinovaUtil.SortBy("Sequence"));
8586
        if (hasil.length > 0) {
8587
            Ext.each(hasil, function (rec) {
8588
                tblTemp = rec.TableName;
8589
                if (tbl != tblTemp) {
8590
                    tbl = tblTemp;
8591
                    if (allTable == null) {
8592
                        allTable = tbl
8593
                    } else {
8594
                        allTable = allTable + ',' + tbl
8595
                    }
8596

    
8597
                }
8598
                // build form
8599
                if (rec.TableRef != '') {
8600
                    valueField = null;
8601
                    displayValue = null;
8602
                    Ext.Ajax.request({
8603
                        async: false,
8604
                        method: 'POST',
8605
                        url: '/UserControl/GetStore',
8606
                        params: {
8607
                            tableName: 'SDATATABLEFIELD',
8608
                            param: 'TableName[equal]' + rec.TableRef
8609
                        },
8610
                        success: function (response) {
8611
                            var results = Ext.decode(response.responseText);
8612
                            data_ = results.data;
8613
                            if (data_ != undefined) {
8614
                                valueField_ = $.grep(data_, function (r) {
8615
                                    return r.ValueField == '1'
8616
                                });
8617
                                if (valueField_.length > 0) {
8618
                                    valueField = valueField_[0].FieldName
8619
                                }
8620

    
8621
                                displayValue_ = $.grep(data_, function (r) {
8622
                                    return r.DisplayValue == '1'
8623
                                });
8624
                                if (displayValue_.length > 0) {
8625
                                    displayValue = displayValue_[0].FieldName
8626
                                }
8627
                            }
8628
                        }
8629
                    });
8630

    
8631
                    formfield = new Ext.form.Display({
8632
                        fieldLabel: rec.ScreenCaption,
8633
                        name: rec.FieldName,
8634
                        //value: rec.DefaultValue,
8635
                        padding: 0,
8636
                        labelCls: 'label-minova',
8637
                        labelWidth: 150,
8638
                        anchor: '80%',
8639
                        store: Ext.create('Ext.data.Store', {
8640
                            storeId: 'storeDisplay' + rec.FieldName,
8641
                            //autoLoad: true,
8642
                            proxy: {
8643
                                method: 'POST',
8644
                                type: 'ajax',
8645
                                extraParams: {
8646
                                    tableName: rec.TableRef,
8647
                                    param: ''
8648
                                },
8649
                                reader: {
8650
                                    type: 'json',
8651
                                    root: 'data',
8652
                                    totalProperty: 'data[0].TotalCount'
8653
                                }
8654
                            }
8655
                        }),
8656
                        listeners: {
8657
                            afterrender: function (f) {
8658
                                var store = Ext.StoreMgr.lookup('storeDisplay' + rec.FieldName);
8659
                                var ParamCombo = rec.ParamCombo;
8660
                                var param = '';
8661
                                //if (ParamCombo != '') {
8662
                                if ((rec.TableRef).toLowerCase() == 'phrom0001') {
8663
                                    var splitParam = ParamCombo.split(']');
8664
                                    switch (rec.FieldName) {
8665
                                        case 'Position':
8666
                                            ParamCombo = 'P'
8667
                                            break;
8668
                                        case 'CostCenter':
8669
                                            ParamCombo = 'CC'
8670
                                            break;
8671
                                        case 'Organization':
8672
                                            ParamCombo = 'O'
8673
                                            break;
8674
                                        case 'Job':
8675
                                            ParamCombo = 'J'
8676
                                            break;
8677
                                    }
8678
                                    //if (splitParam.length == 1) {
8679
                                    param = 'StartDate[<=]' + MinovaUtil.GetNowDate() + 'EndDate[>=]' + MinovaUtil.GetNowDate() + ',ObjectClass[=]' + ParamCombo
8680
                                    //} else {
8681
                                    //    param = ParamCombo;
8682
                                    //}
8683
                                }
8684
                                //}
8685
                                Ext.Ajax.request({
8686
                                    method: 'POST',
8687
                                    async: false,
8688
                                    url: '/UserControl/GetStore',
8689
                                    params: {
8690
                                        tableName: rec.TableRef,
8691
                                        param: param
8692
                                    },
8693
                                    success: function (response) {
8694
                                        var results = Ext.decode(response.responseText);
8695

    
8696
                                        //dt = results.data;
8697
                                        store.loadData(results.data);
8698

    
8699
                                    }
8700
                                });
8701
                            },
8702
                            change: function (f) {
8703
                                //alert(this.valueField, value);
8704
                                var display = this.displayField;
8705
                                var value = this.getValue();
8706
                                var st = f.store
8707
                                var r = st.findRecord(f.valueField, f.value)
8708
                                if (r != null) {
8709
                                    f.setRawValue(r.get(f.displayField))
8710
                                } else {
8711
                                    f.setRawValue(f.value);
8712

    
8713
                                }
8714
                            }
8715

    
8716
                        },
8717
                        queryMode: 'local',
8718
                        displayField: displayValue,
8719
                        valueField: valueField,
8720
                    });
8721
                } else {
8722
                    formfield = new Ext.form.Display({
8723
                        fieldLabel: rec.ScreenCaption,
8724
                        name: rec.FieldName,
8725
                        labelCls: 'label-minova',
8726
                        labelWidth: 150,
8727
                        //value: rec.DefaultValue,
8728
                        padding: 0,
8729
                        anchor: '80%'
8730
                    });
8731
                }
8732
                if (isDesk) {
8733
                    if (rec.Column == 1) {
8734
                        col1.push(formfield);
8735
                    } else {
8736
                        col2.push(formfield);
8737
                    }
8738
                } else {
8739
                    col1.push(formfield);
8740
                }
8741

    
8742
            });
8743
            //set allTable
8744
            this.setAllTableName(allTable);
8745
        }
8746

    
8747
        Ext.applyIf(me, {
8748
            items: [{
8749
                bodyPadding: 0,
8750
                width: 400,
8751
                margin: '10 5 3 30',
8752
                items: col1
8753
            }, {
8754
                bodyPadding: 0,
8755
                width: 400,
8756
                margin: '10 5 3 30',
8757
                items: col2
8758
            }, {
8759
                width: 150,
8760
                //margin: '10 5 3 30',
8761
                items: [{
8762
                    xtype: 'image',
8763
                    id: 'imageusermd',
8764
                    name: 'imageusermd',
8765
                    width: 120,
8766
                    height: 150,
8767
                    padding: 5,
8768
                    border: true,
8769
                    src: '/Devt/GetFileData?FileName=' + Photo + '&download=false',
8770
                }
8771
                ]
8772
            }
8773
            ],
8774
        });
8775
        me.callParent(arguments);
8776

    
8777
    }
8778
});
8779
/*Add Taufan (Header Master Data For ERP)*/
8780
Ext.define('MinovaUtil.MinovaES.MinovaHeaderMDLogistic', {
8781
    extend: 'Ext.form.Panel',
8782
    alias: ['widget.MinovaHeadermdLogistic', 'widget.MinovaHeaderMDLogistic', 'widget.minovaheadermdlogistic'],
8783
    tablenameheader: undefined,
8784
    keyid: undefined,
8785
    allTableName: undefined,
8786
    param: undefined,
8787
    resizable: true,
8788
    autoScroll: true,
8789
    minHeight: 20,
8790
    layout: 'column',
8791
    name: 'HeaderMDLogistic',
8792
    getAllTableName: function () {
8793
        return this.allTableName;
8794
    },
8795
    setAllTableName: function (value) {
8796
        var me = this;
8797
        me.allTableName = value;
8798
        return me;
8799
    },
8800
    listeners: {
8801
        afterrender: function (me) {
8802
            var nowDate = MinovaUtil.GetNowDate()
8803
            var allTbl = me.getAllTableName();
8804
            var splitTable = allTbl.split(',')
8805
            splitTable.forEach(function (tbl) {
8806
                var nowDate = MinovaUtil.GetNowDate();
8807
                var parameter = me.keyid + '[=]' + getParam("KeyValue");
8808
                Ext.Ajax.request({
8809
                    method: 'POST',
8810
                    url: '/UserControl/GetStore',
8811
                    params: {
8812
                        tableName: tbl,
8813
                        param: parameter
8814
                    },
8815
                    success: function (response) {
8816
                        var results = Ext.decode(response.responseText);
8817
                        hasil = results.data;
8818
                        if (hasil.length > 0) {
8819
                            me.getForm().setValues(hasil[0]);
8820
                        }
8821
                    }
8822
                });
8823
            });
8824
        }
8825
    },
8826
    initComponent: function () {
8827
        var me = this;
8828
        var col1 = [];
8829
        var col2 = [];
8830
        var hasil = null;
8831
        var LangId = localStorage.LangId;
8832
        var allTable = null;
8833
        var tbl = null;
8834
        var tblTemp = null;
8835
        var nowDate = MinovaUtil.GetNowDate();
8836
        var Photo = 'nophoto.gif';
8837
        var hasil = undefined;
8838
        var parameter = me.keyid + '[=]' + getParam("KeyValue");
8839
        Ext.Ajax.request({
8840
            method: 'POST',
8841
            async: false,
8842
            url: '/UserControl/GetStore',
8843
            params: {
8844
                tableName: me.tablenameheader,
8845
                param: parameter
8846
            },
8847
            success: function (response) {
8848
                var results = Ext.decode(response.responseText);
8849
                hasil = results.data;
8850
                if (hasil.length > 0) {
8851
                    dataPhoto = hasil[0].Photo
8852
                    if (dataPhoto != "") {
8853
                        Photo = dataPhoto;
8854
                    }
8855
                }
8856
            }
8857
        });
8858
        Ext.Ajax.request({
8859
            async: false,
8860
            method: 'POST',
8861
            url: '/UserControl/GetStore',
8862
            params: {
8863
                tableName: 'PDSBS0009',
8864
                param: 'MenuID[=]' + MinovaUtil.GetMenuID() + ',LangId[=]' + LangId
8865
            },
8866
            success: function (response) {
8867
                hasil = Ext.decode(response.responseText).data;
8868
            }
8869
        });
8870
        hasil = hasil.sort(MinovaUtil.SortBy("Sequence"));
8871
        if (hasil.length > 0) {
8872
            Ext.each(hasil, function (rec) {
8873
                tblTemp = rec.TableName;
8874
                if (tbl != tblTemp) {
8875
                    tbl = tblTemp;
8876
                    if (allTable == null) {
8877
                        allTable = tbl
8878
                    } else {
8879
                        allTable = allTable + ',' + tbl
8880
                    }
8881
                }
8882
                if (rec.TableRef != '') {
8883
                    valueField = null;
8884
                    displayValue = null;
8885
                    Ext.Ajax.request({
8886
                        async: false,
8887
                        method: 'POST',
8888
                        url: '/UserControl/GetStore',
8889
                        params: {
8890
                            tableName: 'SDATATABLEFIELD',
8891
                            param: 'TableName[equal]' + rec.TableRef
8892
                        },
8893
                        success: function (response) {
8894
                            var results = Ext.decode(response.responseText);
8895
                            data_ = results.data;
8896
                            if (data_ != undefined) {
8897
                                valueField_ = $.grep(data_, function (r) {
8898
                                    return r.ValueField == '1'
8899
                                });
8900
                                if (valueField_.length > 0) {
8901
                                    valueField = valueField_[0].FieldName
8902
                                }
8903
                                displayValue_ = $.grep(data_, function (r) {
8904
                                    return r.DisplayValue == '1'
8905
                                });
8906
                                if (displayValue_.length > 0) {
8907
                                    displayValue = displayValue_[0].FieldName
8908
                                }
8909
                            }
8910
                        }
8911
                    });
8912

    
8913
                    formfield = new Ext.form.Display({
8914
                        fieldLabel: rec.ScreenCaption,
8915
                        name: rec.FieldName,
8916
                        padding: 0,
8917
                        labelCls: 'label-minova',
8918
                        labelWidth: 150,
8919
                        anchor: '80%',
8920
                        store: Ext.create('Ext.data.Store', {
8921
                            storeId: 'storeDisplay' + rec.FieldName,
8922
                            proxy: {
8923
                                method: 'POST',
8924
                                type: 'ajax',
8925
                                extraParams: {
8926
                                    tableName: rec.TableRef,
8927
                                    param: ''
8928
                                },
8929
                                reader: {
8930
                                    type: 'json',
8931
                                    root: 'data',
8932
                                    totalProperty: 'data[0].TotalCount'
8933
                                }
8934
                            }
8935
                        }),
8936
                        listeners: {
8937
                            afterrender: function (f) {
8938
                                var store = Ext.StoreMgr.lookup('storeDisplay' + rec.FieldName);
8939
                                var ParamCombo = rec.ParamCombo;
8940
                                var param = '';
8941
                                Ext.Ajax.request({
8942
                                    method: 'POST',
8943
                                    async: false,
8944
                                    url: '/UserControl/GetStore',
8945
                                    params: {
8946
                                        tableName: rec.TableRef,
8947
                                        param: param
8948
                                    },
8949
                                    success: function (response) {
8950
                                        var results = Ext.decode(response.responseText);
8951
                                        store.loadData(results.data);
8952
                                    }
8953
                                });
8954
                            },
8955
                            change: function (f) {
8956
                                var display = this.displayField;
8957
                                var value = this.getValue();
8958
                                var st = f.store
8959
                                var r = st.findRecord(f.valueField, f.value)
8960
                                if (r != null) {
8961
                                    f.setRawValue(r.get(f.displayField))
8962
                                } else {
8963
                                    f.setRawValue(f.value);
8964
                                }
8965
                            }
8966
                        },
8967
                        queryMode: 'local',
8968
                        displayField: displayValue,
8969
                        valueField: valueField,
8970
                    });
8971
                } else {
8972
                    formfield = new Ext.form.Display({
8973
                        fieldLabel: rec.ScreenCaption,
8974
                        name: rec.FieldName,
8975
                        labelCls: 'label-minova',
8976
                        labelWidth: 150,
8977
                        padding: 0,
8978
                        anchor: '80%'
8979
                    });
8980
                }
8981
                if (isDesk) {
8982
                    if (rec.Column == 1) {
8983
                        col1.push(formfield);
8984
                    } else {
8985
                        col2.push(formfield);
8986
                    }
8987
                } else {
8988
                    col1.push(formfield);
8989
                }
8990

    
8991
            });
8992
            this.setAllTableName(allTable);
8993
        }
8994
        Ext.applyIf(me, {
8995
            items: [{
8996
                bodyPadding: 0,
8997
                width: 400,
8998
                margin: '10 5 3 30',
8999
                items: col1
9000
            }, {
9001
                bodyPadding: 0,
9002
                width: 400,
9003
                margin: '10 5 3 30',
9004
                items: col2
9005
            }, {
9006
                width: 150,
9007
                items: [{
9008
                    xtype: 'image',
9009
                    id: 'imageusermd',
9010
                    name: 'imageusermd',
9011
                    width: 120,
9012
                    height: 150,
9013
                    padding: 5,
9014
                    border: true,
9015
                    src: '/Devt/GetFileData?FileName=' + Photo + '&download=false',
9016
                }
9017
                ]
9018
            }
9019
            ]
9020
        });
9021
        me.callParent(arguments);
9022
    }
9023
});
9024
Ext.define('MinovaUtil.MinovaES.Column.MinovaDateTimeColumn', {
9025
    extend: 'Ext.grid.column.Column',
9026
    alias: ['widget.minovadatetimecolumn'],
9027
    alternateClassName: 'Ext.grid.MinovaDateTimeColumn',
9028
    undefinedText: '&#160;',
9029
    defaultRenderer: function (value) {
9030
        //hamid200916
9031
        //if (value === undefined) {
9032
        if (value === "") {
9033
            return this.undefinedText;
9034
            //end
9035
        }
9036

    
9037
        var d = value.substring(6, 8);
9038
        var m = value.substring(4, 6);
9039
        var y = value.substring(0, 4);
9040
        var h = value.substring(8, 10);
9041
        var mt = value.substring(10, 12);
9042
        var s = value.substring(12, 14);
9043
        var hasil = d + '/' + m + '/' + y + '  ' + '  ' + h + ':' + mt + ':' + s;
9044
        return hasil;
9045
    }
9046
});
9047
Ext.define('MinovaUtil.MinovaES.Column.MinovaDateColumn', {
9048
    extend: 'Ext.grid.column.Column',
9049
    alias: ['widget.minovadatecolumn'],
9050
    alternateClassName: 'Ext.grid.MinovaDateColumn',
9051
    undefinedText: '&#160;',
9052
    defaultRenderer: function (value) {
9053
        if (value === "" || value === undefined || value === null) {
9054
            return "";
9055
        }
9056
        var d = value.substring(6, 8);
9057
        var m = value.substring(4, 6);
9058
        var y = value.substring(0, 4);
9059
        var hasil = d + '/' + m + '/' + y;
9060
        return hasil;
9061
    }
9062
});
9063
Ext.define('MinovaUtil.MinovaES.MinovaComboColumn', {
9064
    extend: 'Ext.grid.column.Column',
9065
    alias: ['widget.minovacombocolumn'],
9066
    initComponent: function () {
9067
        this.callParent(arguments);
9068
    },
9069
    defaultRenderer: function (value) {
9070
        if (typeof(this.store) !== 'object') {
9071
            Ext.data.StoreManager.lookup(this.store).load();
9072
            this.store = Ext.data.StoreManager.lookup(this.store);
9073
        }
9074
        var idx = this.store.findExact(this.valueField, value);
9075
        if (this.store.getAt(idx)) {
9076
            var result = this.store.getAt(idx).get(this.displayField);
9077
            value = result ? result : value;
9078
        }
9079
        return value;
9080
    }
9081
});
9082
//atien
9083
Ext.define('MinovaUtil.MinovaES.MinovaAmountColumn', {
9084
    extend: 'Ext.grid.column.Column',
9085
    alias: ['widget.minovaamountcolumn'],
9086
    initComponent: function () {
9087
        this.callParent(arguments);
9088
    },
9089
    defaultRenderer: function (value) {
9090
        if (value != "") {
9091
            Ext.Ajax.request({
9092
                async: false,
9093
                method: 'POST',
9094
                url: '/Devt/DecryptData',
9095
                params: {
9096
                    dt: value
9097

    
9098
                },
9099
                success: function (response) {
9100
                    var results = Ext.decode(response.responseText);
9101
                    value = results.data;
9102
                    Ext.util.Format.thousandSeparator = "."
9103

    
9104
                    value = Ext.util.Format.number(value, '0,000');
9105
                }
9106
            });
9107
        }
9108

    
9109
        return value;
9110
    }
9111
});
9112
//end amount column
9113
//hamid200916
9114
Ext.define('MinovaUtil.MinovaES.MinovaMDApplicant', {
9115
    extend: 'Ext.form.Panel',
9116
    alias: ['widget.minovamdApp', 'widget.MinovaMDApplicant'],
9117
    controller: 'recruitment-controller',
9118
    tableName: undefined, //nama tabel
9119
    param: undefined, //param query
9120
    pagesize: undefined,
9121
    storename: undefined,
9122
    titleform: undefined,
9123
    titlegrid: undefined,
9124
    heightgrid: undefined,
9125
    heightform: undefined,
9126
    iseditform: undefined,
9127
    lastheightform: undefined,
9128
    layoutType: undefined,
9129
    lastpage: undefined,
9130
    lastTitle: undefined,
9131
    getLastTitle: function () {
9132
        return this.lastTitle;
9133
    },
9134
    setLastTitle: function (value) {
9135
        var me = this;
9136
        me.lastTitle = value;
9137
        return me;
9138
    },
9139
    getLastpage: function () {
9140
        return this.lastpage;
9141
    },
9142
    setLastpage: function (value) {
9143
        var me = this;
9144
        me.lastpage = value;
9145
        return me;
9146
    },
9147
    getLayoutType: function () {
9148
        return this.layoutType;
9149
    },
9150
    setLayoutType: function (value) {
9151
        var me = this;
9152
        me.layoutType = value;
9153
        return me;
9154
    },
9155
    getLastheightform: function () {
9156
        return this.lastheightform;
9157
    },
9158
    setLastheightform: function (value) {
9159
        var me = this;
9160
        me.lastheightform = value;
9161
        return me;
9162
    },
9163

    
9164
    getIsEditform: function () {
9165
        return this.iseditform;
9166
    },
9167
    setIsEditform: function (value) {
9168
        var me = this;
9169
        me.iseditform = value;
9170
        return me;
9171
    },
9172
    initComponent: function () {
9173
        var me = this;
9174
        var storename = me.storename;
9175
        if (storename == "" || storename == undefined) {
9176
            storename = "store" + me.tableName;
9177
        }
9178
        var isHired = false;
9179
        nowDate = MinovaUtil.GetNowDate();
9180
        Ext.Ajax.request({
9181
            async: false,
9182
            method: 'POST',
9183
            url: '/UserControl/GetStore',
9184
            params: {
9185
                tableName: 'PHRRC0002',
9186
                param: 'StartDate[<=]' + nowDate + ',EndDate[>=]' + nowDate + ',EmployeeID[=]' + getParam("ApplicantID")
9187

    
9188
            },
9189
            success: function (response) {
9190
                var results = Ext.decode(response.responseText);
9191
                dataForm = results.data;
9192
                //cek is hired or blacklist
9193
                dataForm_ = $.grep(dataForm, function (r) {
9194
                    return r.ApplicantStatus == '05'
9195
                });
9196
                if (dataForm_.length == 0) {
9197
                    dataForm_ = $.grep(dataForm, function (r) {
9198
                        return r.ApplicantStatus == '99'
9199
                    });
9200
                }
9201
                if (dataForm_ != null && dataForm_.length > 0) {
9202
                    isHired = true;
9203
                }
9204
            }
9205
        });
9206

    
9207
        var tableName = me.tableName;
9208
        Ext.applyIf(me, {
9209
            items: [{
9210
                layoutType: "MinovaGridForm",
9211
                title: me.titlegrid,
9212
                xtype: "minovagrid1",
9213
                tableName: tableName, // nama tebel/dataset
9214
                name: "MinovaGridFormGrid",
9215
                param: me.param, // parameter filteran
9216
                pagesize: me.pagesize, // jumlah record yang muncul per page
9217
                storename: storename, //nama store bebas
9218
                isLookup: me.isLookup, // apakah grid untuk look up? jika ya isi dengan 1 atau 'Y' kalau bukan isi string kosong
9219
                height: 330,
9220
                bodyPadding: 0,
9221
                tbar: [{
9222

    
9223
                    xtype: 'button',
9224
                    text: 'Action',
9225
                    name: 'actionGrid',
9226
                    hidden: isHired,
9227
                    menu: [{
9228
                        text: 'Add',
9229
                        name: 'addGrid',
9230
                        action: 'CRUDaddNewRecord',
9231
                        style: 'font-family: FontAwesome',
9232
                        itemId: 'AddData',
9233
                        iconCls: 'fa-plus-circle',
9234
                        hidden: isHired
9235

    
9236
                    }, {
9237
                        text: 'Copy',
9238
                        name: 'CopyGrid',
9239
                        iconCls: 'fa-copy',
9240
                        style: 'font-family: FontAwesome',
9241
                        hidden: isHired
9242
                    }, {
9243
                        text: 'Edit',
9244
                        name: 'EditGrid',
9245
                        iconCls: 'fa-edit',
9246
                        style: 'font-family: FontAwesome',
9247
                        hidden: isHired
9248
                    }, {
9249
                        text: 'Delete',
9250
                        name: 'DeleteGrid',
9251
                        hidden: true,
9252
                        iconCls: 'fa-trash-o',
9253
                        style: 'font-family: FontAwesome',
9254
                    }
9255
                    ],
9256
                    listeners: {
9257
                        afterender: function () {
9258
                            var me = this;
9259
                            nowDate = MinovaUtil.GetNowDate();
9260
                            var isHired = false;
9261
                            Ext.Ajax.request({
9262
                                async: false,
9263
                                method: 'POST',
9264
                                url: '/UserControl/GetStore',
9265
                                params: {
9266
                                    tableName: 'PHRRC0027',
9267
                                    param: 'StartDate[<=]' + nowDate + ',EndDate[>=]' + nowDate + ',EmployeeID[=]' + getParam("ApplicantID") + ',ActivityType[=]8'
9268

    
9269
                                },
9270
                                success: function (response) {
9271
                                    var results = Ext.decode(response.responseText);
9272
                                    dataForm = results.data;
9273
                                    if (dataForm != null) {
9274
                                        isHired = true;
9275
                                    }
9276
                                }
9277
                            });
9278
                            if (isHired) {
9279
                                me.setHidden(true);
9280
                            } else {
9281
                                me.setHidden(false);
9282
                            }
9283

    
9284
                        },
9285

    
9286
                    },
9287
                }, {
9288
                    xtype: 'tbfill'
9289
                }, {
9290
                    text: 'Clear Filters',
9291
                    tooltip: 'Clear all filters',
9292
                    name: 'clearbtn',
9293
                    handler: function () {
9294
                        var tolbar = this.up()
9295
                        var grid_ = tolbar.up()
9296
                        grid_.filters.clearFilters()
9297
                    }
9298
                }, ],
9299

    
9300
                dockedItems: [{
9301
                    xtype: 'pagingtoolbar',
9302
                    store: storename, // harus sama dengan naa store diatas
9303
                    dock: 'bottom', //posisi paging
9304
                    pageSize: me.pagesize,
9305
                    displayInfo: true
9306
                }
9307
                ],
9308

    
9309
            }, {
9310
                xtype: 'minovaform',
9311
                name: "MinovaGridFormDisplay",
9312
                tableName: tableName, // nama tabel /dataset
9313
                isLookup: '', // 1 or 'Y' for lookup
9314
                isDisplay: true, // true== form is displayfield
9315
            }, {
9316
                xtype: 'minovaform',
9317
                name: "MinovaGridFormEdit",
9318
                tableName: tableName, // nama tabel /dataset
9319
                isLookup: '', // 1 or 'Y' for lookup
9320
                isDisplay: false, // true== form is displayfield
9321
            }
9322
            ]
9323
        });
9324
        me.callParent(arguments);
9325
    }
9326
});
9327
//end
9328

    
9329
Ext.define('MinovaUtil.MinovaES.MinovaMD', {
9330
    extend: 'Ext.form.Panel',
9331
    alias: ['widget.minovamd', 'widget.MinovaMD'],
9332
    controller: 'pa-controller',
9333
    tableName: undefined, //nama tabel
9334
    param: undefined, //param query
9335
    pagesize: undefined,
9336
    storename: undefined,
9337
    titleform: undefined,
9338
    titlegrid: undefined,
9339
    heightgrid: undefined,
9340
    heightform: undefined,
9341
    iseditform: undefined,
9342
    lastheightform: undefined,
9343
    layoutType: undefined,
9344
    lastpage: undefined,
9345
    lastTitle: undefined,
9346
    getLastTitle: function () {
9347
        return this.lastTitle;
9348
    },
9349
    setLastTitle: function (value) {
9350
        var me = this;
9351
        me.lastTitle = value;
9352
        return me;
9353
    },
9354
    getLastpage: function () {
9355
        return this.lastpage;
9356
    },
9357
    setLastpage: function (value) {
9358
        var me = this;
9359
        me.lastpage = value;
9360
        return me;
9361
    },
9362
    getLayoutType: function () {
9363
        return this.layoutType;
9364
    },
9365
    setLayoutType: function (value) {
9366
        var me = this;
9367
        me.layoutType = value;
9368
        return me;
9369
    },
9370
    getLastheightform: function () {
9371
        return this.lastheightform;
9372
    },
9373
    setLastheightform: function (value) {
9374
        var me = this;
9375
        me.lastheightform = value;
9376
        return me;
9377
    },
9378

    
9379
    getIsEditform: function () {
9380
        return this.iseditform;
9381
    },
9382
    setIsEditform: function (value) {
9383
        var me = this;
9384
        me.iseditform = value;
9385
        return me;
9386
    },
9387
    initComponent: function () {
9388
        var me = this;
9389
        var storename = me.storename;
9390
        if (storename == "" || storename == undefined) {
9391
            storename = "store" + me.tableName;
9392
        }
9393
        var tableName = me.tableName;
9394
        Ext.applyIf(me, {
9395
            items: [{
9396
                layoutType: "MinovaGridForm",
9397
                title: me.titlegrid,
9398
                xtype: "minovagrid1",
9399
                tableName: tableName, // nama tebel/dataset
9400
                name: "MinovaGridFormGrid",
9401
                param: me.param, // parameter filteran
9402
                pagesize: me.pagesize, // jumlah record yang muncul per page
9403
                storename: storename, //nama store bebas
9404
                isLookup: me.isLookup, // apakah grid untuk look up? jika ya isi dengan 1 atau 'Y' kalau bukan isi string kosong
9405
                height: 330,
9406
                bodyPadding: 0,
9407
                tbar: [{
9408
                    xtype: 'button',
9409
                    text: 'Action',
9410
                    name: 'actionGrid',
9411
                    menu: [{
9412
                        text: 'Add',
9413
                        name: 'addGrid',
9414
                        action: 'CRUDaddNewRecord',
9415
                        style: 'font-family: FontAwesome',
9416
                        itemId: 'AddData',
9417
                        iconCls: 'fa-plus-circle',
9418

    
9419
                    }, {
9420
                        text: 'Copy',
9421
                        name: 'CopyGrid',
9422
                        iconCls: 'fa-copy',
9423
                        style: 'font-family: FontAwesome',
9424
                    }, {
9425
                        text: 'Edit',
9426
                        name: 'EditGrid',
9427
                        iconCls: 'fa-edit',
9428
                        style: 'font-family: FontAwesome',
9429
                    }, {
9430
                        text: 'Delete',
9431
                        name: 'DeleteGrid',
9432
                        hidden: true,
9433
                        iconCls: 'fa-trash-o',
9434
                        style: 'font-family: FontAwesome',
9435
                    }
9436
                    ]
9437
                }, {
9438
                    xtype: 'tbfill'
9439
                }, {
9440
                    text: 'Clear Filters',
9441
                    tooltip: 'Clear all filters',
9442
                    name: 'clearbtn',
9443
                    handler: function () {
9444
                        var tolbar = this.up()
9445
                        var grid_ = tolbar.up()
9446
                        grid_.filters.clearFilters()
9447
                    }
9448
                }, ],
9449

    
9450
                dockedItems: [{
9451
                    xtype: 'pagingtoolbar',
9452
                    store: storename, // harus sama dengan naa store diatas
9453
                    dock: 'bottom', //posisi paging
9454
                    pageSize: me.pagesize,
9455
                    displayInfo: true
9456
                }
9457
                ],
9458

    
9459
            }, {
9460
                xtype: 'minovaform',
9461
                name: "MinovaGridFormDisplay",
9462
                tableName: tableName, // nama tabel /dataset
9463
                isLookup: '', // 1 or 'Y' for lookup
9464
                isDisplay: true, // true== form is displayfield
9465
            }, {
9466
                xtype: 'minovaform',
9467
                name: "MinovaGridFormEdit",
9468
                tableName: tableName, // nama tabel /dataset
9469
                isLookup: '', // 1 or 'Y' for lookup
9470
                isDisplay: false, // true== form is displayfield
9471
            }
9472
            ]
9473
        });
9474
        me.callParent(arguments);
9475
    }
9476
});
9477

    
9478
Ext.define('MinovaUtil.MinovaES.MinovaCustomization', {
9479
    extend: 'Ext.form.Panel',
9480
    alias: ['widget.minovacustomization', 'widget.MinovaCustomization'],
9481
    controller: 'treeCustomization',
9482
    tableName: undefined, //nama tabel
9483
    param: undefined, //param query
9484
    pagesize: undefined,
9485
    storename: undefined,
9486
    titleform: undefined,
9487
    titlegrid: undefined,
9488
    heightgrid: undefined,
9489
    heightform: undefined,
9490
    iseditform: undefined,
9491
    lastheightform: undefined,
9492
    layoutType: undefined,
9493
    lastpage: undefined,
9494
    lastTitle: undefined,
9495
    collapsibleForm: undefined,
9496
    getLastTitle: function () {
9497
        return this.lastTitle;
9498
    },
9499
    setLastTitle: function (value) {
9500
        var me = this;
9501
        me.lastTitle = value;
9502
        return me;
9503
    },
9504
    getLastpage: function () {
9505
        return this.lastpage;
9506
    },
9507
    setLastpage: function (value) {
9508
        var me = this;
9509
        me.lastpage = value;
9510
        return me;
9511
    },
9512
    getLayoutType: function () {
9513
        return this.layoutType;
9514
    },
9515
    setLayoutType: function (value) {
9516
        var me = this;
9517
        me.layoutType = value;
9518
        return me;
9519
    },
9520
    getLastheightform: function () {
9521
        return this.lastheightform;
9522
    },
9523
    setLastheightform: function (value) {
9524
        var me = this;
9525
        me.lastheightform = value;
9526
        return me;
9527
    },
9528

    
9529
    getIsEditform: function () {
9530
        return this.iseditform;
9531
    },
9532
    setIsEditform: function (value) {
9533
        var me = this;
9534
        me.iseditform = value;
9535
        return me;
9536
    },
9537
    initComponent: function () {
9538
        var me = this;
9539
        var storename = me.storename;
9540
        if (storename == "" || storename == undefined) {
9541
            storename = "store" + me.tableName;
9542
        }
9543
        var tableName = me.tableName;
9544
        var collapsibleForm_ = me.collapsibleForm;
9545
        // if (!collapsibleForm_) {
9546
        //  collapsibleForm_ = false;
9547
        //}
9548
        Ext.applyIf(me, {
9549
            items: [{
9550
                layoutType: "MinovaGridForm",
9551
                title: me.titlegrid,
9552
                xtype: "minovagrid1",
9553
                tableName: tableName, // nama tebel/dataset
9554
                name: "MinovaGridFormGrid",
9555
                param: me.param, // parameter filteran
9556
                pagesize: me.pagesize, // jumlah record yang muncul per page
9557
                storename: storename, //nama store bebas
9558
                isLookup: me.isLookup, // apakah grid untuk look up? jika ya isi dengan 1 atau 'Y' kalau bukan isi string kosong
9559
                height: 480,
9560
                bodyPadding: 0,
9561
                tbar: [{
9562
                    xtype: 'button',
9563
                    text: 'Action',
9564
                    name: 'actionGrid',
9565
                    menu: [{
9566
                        text: 'Add',
9567
                        name: 'addGrid',
9568
                        action: 'CRUDaddNewRecord',
9569
                        style: 'font-family: FontAwesome',
9570
                        itemId: 'AddData',
9571
                        iconCls: 'fa-plus-circle',
9572

    
9573
                    }, {
9574
                        text: 'Copy',
9575
                        name: 'CopyGrid',
9576
                        iconCls: 'fa-copy',
9577
                        style: 'font-family: FontAwesome',
9578
                    }, {
9579
                        text: 'Edit',
9580
                        name: 'EditGrid',
9581
                        iconCls: 'fa-edit',
9582
                        style: 'font-family: FontAwesome',
9583
                    }, {
9584
                        text: 'Delete',
9585
                        name: 'DeleteGrid',
9586
                        hidden: true,
9587
                        iconCls: 'fa-trash-o',
9588
                        style: 'font-family: FontAwesome',
9589
                    }
9590
                    ]
9591
                }, {
9592
                    xtype: 'tbfill'
9593
                }, {
9594
                    text: 'Search',
9595
                    tooltip: 'Search',
9596
                    tableName: tableName,
9597
                    name: 'btnSearchCust',
9598
                    handler: function () {
9599
                        //var tolbar = this.up()
9600
                        //var grid_ = tolbar.up()
9601
                        //alert(this.tableName)
9602

    
9603
                    }
9604

    
9605
                }, {
9606
                    text: 'Import/Export',
9607
                    tooltip: 'Import/Export',
9608
                    name: 'Import/Exportbtn',
9609

    
9610
                }, {
9611
                    text: 'Clear Filters',
9612
                    tooltip: 'Clear all filters',
9613
                    name: 'clearbtn',
9614
                    handler: function () {
9615
                        var tolbar = this.up()
9616
                        var grid_ = tolbar.up()
9617
                        grid_.filters.clearFilters()
9618
                    }
9619
                }
9620
                ],
9621

    
9622
                dockedItems: [{
9623
                    xtype: 'pagingtoolbar',
9624
                    store: storename, // harus sama dengan naa store diatas
9625
                    dock: 'bottom', //posisi paging
9626
                    pageSize: me.pagesize,
9627
                    displayInfo: true
9628
                }
9629
                ],
9630

    
9631
            }, {
9632
                xtype: 'minovaform',
9633
                //layout: 'anchor',
9634
                height: '200',
9635
                collapsible: collapsibleForm_,
9636
                name: "MinovaGridFormDisplay",
9637
                tableName: tableName, // nama tabel /dataset
9638
                isLookup: '', // 1 or 'Y' for lookup
9639
                isDisplay: true, // true== form is displayfield
9640
            }, {
9641
                xtype: 'minovaform',
9642
                //layout:'anchor',
9643
                collapsible: collapsibleForm_,
9644
                name: "MinovaGridFormEdit",
9645
                tableName: tableName, // nama tabel /dataset
9646
                isLookup: '', // 1 or 'Y' for lookup
9647
                isDisplay: false, // true== form is displayfield
9648
            }
9649
            ]
9650
        });
9651
        me.callParent(arguments);
9652
    }
9653
});
9654

    
9655
Ext.define('MinovaUtil.view.override.Panel', {
9656
    override: 'Ext.panel.Panel',
9657

    
9658
    print: function (pnl) {
9659

    
9660
        if (!pnl) {
9661
            pnl = this;
9662
        }
9663

    
9664
        // instantiate hidden iframe
9665

    
9666
        var iFrameId = "printerFrame";
9667
        var printFrame = Ext.get(iFrameId);
9668

    
9669
        if (printFrame == null) {
9670
            printFrame = Ext.getBody().appendChild({
9671
                id: iFrameId,
9672
                tag: 'iframe',
9673
                cls: 'x-hidden',
9674
                style: {
9675
                    display: "none"
9676
                }
9677
            });
9678
        }
9679

    
9680
        var cw = printFrame.dom.contentWindow;
9681

    
9682
        // instantiate application stylesheets in the hidden iframe
9683

    
9684
        var stylesheets = "";
9685
        for (var i = 0; i < document.styleSheets.length; i++) {
9686
            stylesheets += Ext.String.format('<link rel="stylesheet" href="{0}" />', document.styleSheets[i].href);
9687
        }
9688

    
9689
        // various style overrides
9690
        stylesheets += ''.concat(
9691
			"<style>",
9692
			".x-panel-body {overflow: visible !important;}",
9693
			// experimental - page break after embedded panels
9694
			// .x-panel {page-break-after: always; margin-top: 10px}",
9695
			"</style>");
9696

    
9697
        // get the contents of the panel and remove hardcoded overflow properties
9698
        var markup = pnl.getEl().dom.innerHTML;
9699
        while (markup.indexOf('overflow: auto;') >= 0) {
9700
            markup = markup.replace('overflow: auto;', '');
9701
        }
9702

    
9703
        var str = Ext.String.format('<html><head>{0}</head><body>{1}</body></html>', stylesheets, markup);
9704

    
9705
        // output to the iframe
9706
        cw.document.open();
9707
        cw.document.write(str);
9708
        cw.document.close();
9709

    
9710
        // remove style attrib that has hardcoded height property
9711
        cw.document.getElementsByTagName('DIV')[0].removeAttribute('style');
9712

    
9713
        // print the iframe
9714
        cw.print();
9715

    
9716
        // destroy the iframe
9717
        Ext.fly(iFrameId).destroy();
9718

    
9719
    }
9720
});
9721

    
9722
Ext.define('MinovaUtil.MinovaES.MinovaRptForm', {
9723
    extend: 'Ext.form.Panel',
9724
    alias: ['widget.MinovaRptForm', 'widget.minovarptform'],
9725
    ReportID: undefined,
9726
    SelectionType: undefined,
9727
    layout: 'column',
9728
    //frame : true,
9729
    defaults: {
9730
        layout: 'form',
9731
        xtype: 'container',
9732
        defaultType: 'textfield',
9733
        style: 'width: 50%',
9734
        //height: 1000
9735
    },
9736
    initComponent: function () {
9737
        var col1 = [];
9738
        var col2 = [];
9739
        var me = this;
9740
        var hasil = null;
9741
        var hideButton_ = me.hideButton;
9742
        Ext.Ajax.request({
9743
            async: false,
9744
            method: 'POST',
9745
            url: '/UserControl/GetStore',
9746
            params: {
9747
                tableName: 'PDSBS0006',
9748
                //param : "ReportID='" + me.ReportID + "' and SelectionType='" + me.SelectionType + "' and LangId='" + localStorage.LangId + "'"
9749
                param: "ReportID='" + me.ReportID + "',SelectionType='" + me.SelectionType + "',LangId='" + localStorage.LangId + "'"
9750
            },
9751
            success: function (response) {
9752
                var results = Ext.decode(response.responseText);
9753
                hasil = results.data;
9754
                //count = hasil.length
9755
            }
9756
        });
9757
        if (hasil.length > 0) {
9758
            hasil = hasil.sort(MinovaUtil.SortBy("Sequence"));
9759
            var me = this;
9760
            Ext.each(hasil, function (rec) {
9761
                var null_ = true;
9762
                if (rec.IsRequired == '1') {
9763
                    null_ = false;
9764
                } else {
9765
                    null_ = true;
9766
                }
9767
                var formfield = MinovaUtil.FieldGenerator.Form(me.name, rec, null_, false, me.tableName, me.isLookup);
9768
                if (isDesk) {
9769
                    if (rec.ColumnNo == 1) {
9770
                        col1.push(formfield);
9771
                    } else {
9772
                        col2.push(formfield);
9773
                    }
9774
                } else {
9775
                    col1.push(formfield);
9776
                }
9777
            });
9778

    
9779
        }
9780
        Ext.applyIf(me, {
9781
            items: [{
9782
                style: 'width: 50%',
9783
                items: col1
9784
            }, {
9785
                style: 'width: 50%',
9786
                items: col2
9787
            }
9788
            ],
9789
        });
9790
        this.callParent();
9791
    }
9792
});
9793

    
9794
Ext.define('MinovaUtil.MinovaES.MinovaRptSimple', {
9795
    extend: 'Ext.form.Panel',
9796
    alias: ['widget.MinovaRptSimple', 'widget.minovarptsimple'],
9797
    //layout: 'column',
9798
    controller: 'basereports-controller',
9799
    ReportID: undefined,
9800
    hideButton: undefined,
9801
    reportLayout: 'simple',
9802
    getReportLayout: function () {
9803
        return this.reportLayout;
9804
    },
9805
    setReportLayout: function (value) {
9806
        var me = this;
9807
        me.reportLayout = value;
9808
        return me;
9809
    },
9810

    
9811
    initComponent: function () {
9812
        var me = this;
9813
        var ReportID = me.ReportID;
9814
        var hideButton_ = me.hideButton;
9815
        var hide_ = false;
9816
        if (hideButton_) {
9817
            hide_ = true;
9818
        }
9819
        Ext.applyIf(me, {
9820
            items: [{
9821
                //title: 'Report Selection',
9822
                xtype: 'minovarptform',
9823
                hideButton: hide_,
9824
                name: 'minovarptsimple',
9825
                ReportID: ReportID,
9826
                SelectionType: '1',
9827
                bodyPadding: 10,
9828
                buttons: [{
9829
                    text: 'Search',
9830
                    name: 'SearchRpt',
9831
                    hidden: hide_
9832
                }, {
9833
                    text: 'Variant',
9834
                    style: 'font-family: FontAwesome',
9835
                    hidden: hide_,
9836
                    menu: [{
9837
                        text: 'Load Variant',
9838
                        name: 'loadvariant',
9839

    
9840
                    }, {
9841
                        text: 'Save Variant',
9842
                        name: 'savevariant',
9843

    
9844
                    }
9845
                    ],
9846

    
9847
                }
9848
                ],
9849

    
9850
            },
9851
				//{
9852
				//    title: 'Result',
9853
				//    height: 530,
9854
				//    collapsible: false,
9855
				//    name: 'resultPanel',
9856
				//    layout: 'fit',
9857
				//    html: '<div  id="formMdDiv"></div>',
9858
				//}
9859
            ],
9860
        });
9861
        this.callParent();
9862
    }
9863
});
9864

    
9865
Ext.define('MinovaUtil.MinovaES.MinovaRptAdvance', {
9866
    extend: 'Ext.form.Panel',
9867
    alias: ['widget.MinovaRptAdvance', 'widget.minovarptadvance'],
9868
    //layout: 'column',
9869
    controller: 'basereports-controller',
9870
    ReportID: undefined,
9871
    reportLayout: 'advance',
9872
    hideButton: undefined,
9873
    getReportLayout: function () {
9874
        return this.reportLayout;
9875
    },
9876
    setReportLayout: function (value) {
9877
        var me = this;
9878
        me.reportLayout = value;
9879
        return me;
9880
    },
9881

    
9882
    initComponent: function () {
9883
        var me = this;
9884
        var ReportID = me.ReportID;
9885
        var hideButton_ = me.hideButton;
9886
        var hide_ = false;
9887
        if (hideButton_) {
9888
            hide_ = true;
9889
        }
9890
        Ext.applyIf(me, {
9891
            items: [{
9892
                //title: 'Report Selection',
9893
                xtype: 'minovarptform',
9894
                hideButton: hide_,
9895
                name: 'minovarptadvance',
9896
                ReportID: ReportID,
9897
                SelectionType: '2',
9898
                bodyPadding: 10,
9899
                buttons: [{
9900
                    text: 'Search',
9901
                    name: 'SearchRpt',
9902
                    hidden: hide_
9903
                }, {
9904
                    text: 'Variant',
9905
                    hidden: hide_,
9906
                    style: 'font-family: FontAwesome',
9907
                    menu: [{
9908
                        text: 'Load Variant',
9909
                        name: 'loadvariant',
9910

    
9911
                    }, {
9912
                        text: 'Save Variant',
9913
                        name: 'savevariant',
9914

    
9915
                    }
9916
                    ],
9917

    
9918
                }
9919
                ],
9920

    
9921
            },
9922
				//{
9923
				//    title: 'Result',
9924
				//    height: 530,
9925
				//    collapsible: false,
9926
				//    name: 'resultPanel',
9927
				//    layout: 'fit',
9928
				//    html: '<div  id="formMdDiv"></div>',
9929
				//}
9930
            ],
9931
        });
9932
        this.callParent();
9933
    }
9934
});
9935

    
9936
Ext.define('MinovaUtil.MinovaES.MinovaRptAll', {
9937
    extend: 'Ext.form.Panel',
9938
    alias: ['widget.MinovaRptAll', 'widget.minovarptall'],
9939
    //layout: 'column',
9940
    controller: 'basereports-controller',
9941
    ReportID: undefined,
9942
    titleSimle: undefined,
9943
    titleAdvance: undefined,
9944
    reportLayout: 'all',
9945
    hideButton: undefined,
9946
    getReportLayout: function () {
9947
        return this.reportLayout;
9948
    },
9949
    setReportLayout: function (value) {
9950
        var me = this;
9951
        me.reportLayout = value;
9952
        return me;
9953
    },
9954

    
9955
    initComponent: function () {
9956
        var me = this;
9957
        var ReportID = me.ReportID;
9958
        var hideButton_ = me.hideButton;
9959
        var hide_ = false;
9960
        if (hideButton_) {
9961
            hide_ = true;
9962
        }
9963
        Ext.applyIf(me, {
9964
            items: [{
9965
                xtype: 'tabpanel',
9966
                name: 'mainTab',
9967
                buttons: [{
9968
                    text: 'Search',
9969
                    name: 'SearchRpt',
9970
                    hidden: hide_,
9971
                }, {
9972
                    text: 'Variant',
9973
                    hidden: hide_,
9974
                    style: 'font-family: FontAwesome',
9975
                    menu: [{
9976
                        text: 'Load Variant',
9977
                        name: 'loadvariant',
9978

    
9979
                    }, {
9980
                        text: 'Save Variant',
9981
                        name: 'savevariant',
9982

    
9983
                    }
9984
                    ],
9985

    
9986
                }
9987
                ],
9988

    
9989
                items: [{
9990
                    title: 'Simple',
9991
                    xtype: 'minovarptform',
9992
                    hideButton: hide_,
9993
                    name: 'simpleForm',
9994
                    ReportID: ReportID,
9995
                    SelectionType: '1',
9996
                    bodyPadding: 10,
9997

    
9998
                }, {
9999
                    title: 'Advance',
10000
                    xtype: 'minovarptform',
10001
                    hideButton: hide_,
10002
                    name: 'advanceForm',
10003
                    ReportID: ReportID,
10004
                    SelectionType: '2',
10005
                    bodyPadding: 10,
10006

    
10007
                }
10008
                ]
10009
            },
10010
				//{
10011
				//    title: 'Result',
10012
				//    height: 530,
10013
				//    collapsible: false,
10014
				//    name: 'resultPanel',
10015
				//    layout: 'fit',
10016
				//    html: '<div  id="formMdDiv"></div>',
10017
				//}
10018

    
10019
            ],
10020
        });
10021
        this.callParent();
10022
    }
10023
});
10024

    
10025
Ext.define('MinovaUtil.MinovaES.MinovaGridRpt', {
10026
    extend: 'Ext.grid.Panel',
10027
    requires: ['Ext.grid.RowNumberer'],
10028
    alias: 'widget.minovagridrpt',
10029
    alternateClassName: 'Ext.grid.MinovaGridRpt',
10030
    tableName: undefined,
10031
    param: undefined,
10032
    //pagesize: undefined,
10033
    storename: undefined,
10034
    //layoutType: undefined,
10035
    enableLocking: true,
10036
    tbar: [{
10037
        xtype: 'tbfill'
10038
    }, {
10039
        text: 'Clear Filters',
10040
        tooltip: 'Clear all filters',
10041
        name: 'clearbtn',
10042
        handler: function () {
10043
            var tolbar = this.up()
10044
            var grid_ = tolbar.up()
10045
            grid_.filters.clearFilters()
10046
        }
10047
    }, ],
10048
    getTableName: function () {
10049
        return this.tableName;
10050
    },
10051

    
10052
    initComponent: function () {
10053
        var me = this;
10054
        var cols_ = [];
10055
        var fieldeditor = {};
10056
        var hasil = null;
10057
        var autoLoad = true;
10058
        var _url = 'GetAllField';
10059

    
10060
        Ext.Ajax.request({
10061
            async: false,
10062
            method: 'POST',
10063
            url: '/Devt/' + _url + '?tableName=' + me.tableName,
10064
            success: function (response) {
10065
                var results = Ext.decode(response.responseText);
10066
                hasil = results.data;
10067
            }
10068
        });
10069
        var structure = undefined;
10070
        Ext.Ajax.request({
10071
            async: false,
10072
            method: 'POST',
10073
            url: '/UserControl/GetStore',
10074
            params: {
10075
                tableName: 'SDATATABLEFIELD',
10076
                param: 'TableName[equal]' + me.tableName
10077

    
10078
            },
10079
            success: function (response) {
10080
                var results = Ext.decode(response.responseText);
10081
                data_ = results.data;
10082
                if (data_ != undefined) {
10083
                    structure = data_;
10084
                }
10085
            }
10086
        });
10087
        if (hasil.length > 0) {
10088
            Ext.each(hasil, function (rec) {
10089
                // get field will be summary
10090

    
10091
                var summaryType = undefined;
10092
                if (structure != undefined) {
10093
                    _field = $.grep(structure, function (r) {
10094
                        return r.FieldName == rec.FieldName
10095
                    });
10096
                    summaryType = _field[0].SummaryType
10097
                }
10098

    
10099
                var null_ = null;
10100
                if (rec.IsPrimaryKey == true) {
10101
                    null_ = false;
10102
                }
10103
                if (rec.IsRequired == true) {
10104
                    null_ = false;
10105
                } else {
10106
                    null_ = true;
10107
                }
10108
                if (rec.GridView == 1) {
10109
                    switch (rec.FormatRef) {
10110
                        case "date":
10111
                            cols_.push({
10112
                                xtype: 'minovadatecolumn',
10113
                                text: rec.HeaderTitle,
10114
                                dataIndex: rec.FieldName,
10115
                                summaryType: summaryType,
10116
                                width: 100,
10117
                                filter: {
10118
                                    type: 'date',
10119
                                    itemDefaults: {
10120
                                        emptyText: 'Search for...'
10121
                                    }
10122
                                }
10123
                            });
10124
                            break
10125
                        case "amount":
10126
                            cols_.push({
10127
                                xtype: 'minovacurrancycolumn',
10128
                                align: 'right',
10129
                                text: rec.HeaderTitle,
10130
                                dataIndex: rec.FieldName,
10131
                                summaryType: summaryType,
10132
                                width: 100,
10133
                                filter: {
10134
                                    type: 'number',
10135
                                    itemDefaults: {
10136
                                        emptyText: 'Search for...'
10137
                                    }
10138
                                }
10139
                            });
10140
                            break
10141
                        case "datetime":
10142
                            cols_.push({
10143
                                xtype: 'minovadatetimecolumn',
10144
                                text: rec.HeaderTitle,
10145
                                dataIndex: rec.FieldName,
10146
                                summaryType: summaryType,
10147
                                width: 140,
10148
                                filter: {
10149
                                    type: 'string',
10150
                                    itemDefaults: {
10151
                                        emptyText: 'Search for...'
10152
                                    }
10153
                                }
10154
                            });
10155
                            break
10156
                        default:
10157
                            if (rec.DataRef == 'CREATEBY' || rec.DataRef == 'CHANGEBY') {
10158
                                cols_.push({
10159
                                    text: rec.HeaderTitle,
10160
                                    dataIndex: rec.FieldName,
10161
                                    summaryType: summaryType,
10162
                                    width: 100,
10163
                                    filter: {
10164
                                        type: 'string',
10165
                                        itemDefaults: {
10166
                                            emptyText: 'Search for...'
10167
                                        }
10168
                                    }
10169
                                });
10170
                            } else if (rec.TableRef != "") {
10171
                                if (rec.TableRef != null) {
10172
                                    var valueField = null;
10173
                                    var displayValue = null;
10174
                                    Ext.Ajax.request({
10175
                                        async: false,
10176
                                        method: 'POST',
10177
                                        url: '/UserControl/GetStore',
10178
                                        params: {
10179
                                            tableName: 'SDATATABLEFIELD',
10180
                                            param: 'TableName[equal]' + rec.TableRef
10181
                                        },
10182
                                        success: function (response) {
10183
                                            var results = Ext.decode(response.responseText);
10184
                                            data_ = results.data;
10185
                                            if (data_ != undefined) {
10186
                                                valueField_ = $.grep(data_, function (r) {
10187
                                                    return r.ValueField == '1'
10188
                                                });
10189
                                                valueField = valueField_[0].FieldName
10190
                                                displayValue_ = $.grep(data_, function (r) {
10191
                                                    return r.DisplayValue == '1'
10192
                                                });
10193
                                                displayValue = displayValue_[0].FieldName
10194

    
10195
                                            }
10196
                                        }
10197
                                    });
10198
                                    var store_ = Ext.StoreMgr.lookup('store_' + rec.FieldName);
10199
                                    var count_ = 0;
10200
                                    if (store_) {
10201
                                        count_ = store_.count();
10202
                                    }
10203
                                    if (count_ == 0) {
10204
                                        Ext.create('Ext.data.Store', {
10205
                                            storeId: 'store_' + rec.FieldName,
10206
                                            autoLoad: true,
10207
                                            proxy: {
10208
                                                method: 'POST',
10209
                                                type: 'ajax',
10210
                                                url: '/UserControl/GetStore',
10211
                                                extraParams: {
10212
                                                    tableName: rec.TableRef,
10213
                                                    param: rec.ParamCombo
10214
                                                },
10215
                                                reader: {
10216
                                                    type: 'json',
10217
                                                    root: 'data',
10218
                                                    totalProperty: 'data[0].TotalCount'
10219
                                                }
10220
                                            }
10221
                                        })
10222
                                    }
10223
                                    cols_.push({
10224
                                        xtype: 'minovacombocolumn',
10225
                                        TableRef: rec.TableRef,
10226
                                        text: rec.HeaderTitle,
10227
                                        summaryType: summaryType,
10228
                                        dataIndex: rec.FieldName,
10229
                                        valueField: valueField,
10230
                                        displayField: displayValue,
10231
                                        store: 'store_' + rec.FieldName,
10232
                                        filter: {
10233
                                            type: 'list',
10234
                                            itemDefaults: {
10235
                                                emptyText: 'Search for...'
10236
                                            }
10237
                                        }
10238
                                    });
10239
                                }
10240

    
10241
                            } else {
10242
                                cols_.push({
10243
                                    text: rec.HeaderTitle,
10244
                                    dataIndex: rec.FieldName,
10245
                                    summaryType: summaryType,
10246
                                    filter: {
10247
                                        itemDefaults: {
10248
                                            emptyText: 'Search for...'
10249
                                        }
10250
                                    }
10251
                                });
10252
                            }
10253
                            break
10254
                    }
10255
                } else {
10256
                    cols_.push({
10257
                        text: rec.HeaderTitle,
10258
                        dataIndex: rec.FieldName,
10259
                        hidden: true,
10260
                        filter: {
10261
                            itemDefaults: {
10262
                                emptyText: 'Search for...'
10263
                            }
10264
                        }
10265
                    });
10266
                }
10267
            });
10268
        };
10269
        var param_ = me.param;
10270
        if (param_ == undefined) {
10271
            param_ = ''
10272
        }
10273
        var jsStoreGrid = new Ext.data.Store({
10274
            storeId: me.storename,
10275
            autoLoad: false,
10276
            //pageSize: me.pagesize,
10277
            proxy: {
10278
                method: 'POST',
10279
                type: 'ajax',
10280
                url: '/UserControl/GetStore',
10281
                //extraParams: {
10282
                //    tableName: me.tableName,
10283
                //    param: param_
10284
                //},
10285
                reader: {
10286
                    type: 'json',
10287
                    root: 'data',
10288
                    totalProperty: 'totalRecords'
10289
                }
10290
            }
10291
        });
10292
        Ext.applyIf(me, {
10293
            autoScroll: true,
10294
            enableLocking: true,
10295
            lockedGridConfig: {
10296
                header: false,
10297
                collapsible: true,
10298
                width: 250,
10299
                forceFit: true,
10300
                listeners: {
10301
                    render: function (grid) {
10302
                        var pagingToolbar = grid.child('pagingtoolbar');
10303
                        if (pagingToolbar) {
10304
                            grid.remove(pagingToolbar, true);
10305
                        }
10306
                    }
10307
                }
10308
            },
10309
            listeners: {
10310
                viewready: function () {
10311
                    if (autoLoad == true) {
10312
                        this.getStore().loadPage(1);
10313
                    }
10314

    
10315
                },
10316
                beforeedit: function () {
10317
                    return false;
10318
                }
10319
            },
10320
            lockedViewConfig: {
10321
                scroll: 'horizontal'
10322
            },
10323
            viewConfig: {
10324
                emptyText: 'No Data Display',
10325
                deferEmptyText: false
10326
            },
10327
            //features: [{
10328
            //    ftype: 'summary'
10329
            //}],
10330
            columns: cols_,
10331

    
10332
            store: jsStoreGrid,
10333

    
10334
            plugins: [{
10335
                ptype: 'gridfilters'
10336
            },
10337

    
10338
            ],
10339

    
10340
        });
10341
        me.callParent(arguments);
10342
    }
10343

    
10344
});
10345

    
10346
Ext.define('MinovaUtil.MinovaES.MinovaEditAbleGrid', {
10347
    extend: 'Ext.form.Panel',
10348
    alias: ['widget.MinovaEditAbleGrid', 'widget.Minovaeditablegrid', 'widget.minovaeditablegrid'],
10349
    requires: [
10350
		'Ext.grid.plugin.CellEditing',
10351
		'Ext.grid.RowNumberer',
10352
		'Ext.grid.Panel',
10353
    ],
10354
	
10355
    //renderTo: 'panel-extjs',
10356
    anchor: '100%',
10357
    tableName: undefined,
10358
    hideButton: undefined,
10359
    multiSelect: undefined,
10360
    initComponent: function () {
10361
        var me = this;
10362
        var isLookup = me.isLookup;
10363
        var hide_ = false;
10364
        var widthLock = 250;
10365
        var checkSelection = '';
10366

    
10367
        if (me.hideButton == true) {
10368
            hide_ = true;
10369
        }
10370
        if (me.multiSelect) {
10371
            locking = false;
10372
            checkSelection = 'checkboxmodel';
10373
            widthLock = 40;
10374
        }
10375
        var tableName = me.tableName;
10376
        var cols = [];
10377
        var fieldStore = [];
10378
        var _url = 'GetAllField';
10379
        var hasil = null;
10380
        var height = me.height;
10381
        var storeID = 'store' + me.tableName;
10382
        var gridName = 'grid' + me.name;
10383
        if (me.storeName) {
10384
            storeID = me.storeName;
10385
        }
10386
        var LangID = MinovaUtil.GetLangID();
10387
        var parameter = "LangID='" + LangID + "',TableName='" + me.tableName + "'"
10388
        Ext.Ajax.request({
10389
            async: false,
10390
            method: 'POST',
10391
            url: '/UserControl/GetStore',
10392
            params: {
10393
                tableName: 'PDSBS0007',
10394
                param: parameter
10395
            },
10396
            success: function (response) {
10397
                var results = Ext.decode(response.responseText);
10398
                hasil = results.data;
10399
            }
10400
        });
10401
        cols.push({
10402
            xtype: 'rownumberer'
10403
        });
10404
        var addData = 'var data={';
10405
        if (hasil.length > 0) {
10406
            Ext.each(hasil, function (rec) {
10407
                fieldStore.push(rec.FieldName);
10408
                if (rec.FieldName != 'Sequence') {
10409
                    addData = addData + rec.FieldName + ":" + "'',";
10410
                }
10411

    
10412
                var null_ = null;
10413
                var ReadOnly_ = false;
10414
                if (rec.IsPrimaryKey == true) {
10415
                    null_ = false;
10416
                }
10417
                if (rec.IsRequired == true) {
10418
                    null_ = false;
10419
                } else {
10420
                    null_ = true;
10421
                }
10422
                if (rec.ReadOnly == '1') {
10423
                    ReadOnly_ = true;
10424
                }
10425
                var Hidden_ = false;
10426
                if (rec.ReadOnly == '1') {
10427
                    ReadOnly_ = true;
10428
                }
10429

    
10430
                if (rec.IsHidden == '1' || rec.Sequence == '' || rec.Sequence == '0' || rec.ColumnNo == '' || rec.GridView == '') {
10431
                    Hidden_ = true;
10432
                    null_ = true;
10433
                }
10434

    
10435
                if (rec.GridView == 1) {
10436
                    switch (rec.FormatRef) {
10437
                        case "date":
10438
                            cols.push({
10439
                                xtype: 'minovadatecolumn',
10440
                                hidden: Hidden_,
10441
                                text: rec.HeaderTitle,
10442
                                dataIndex: rec.FieldName,
10443
                                filter: {
10444
                                    itemDefaults: {
10445
                                        emptyText: 'Search for...',
10446

    
10447
                                    }
10448
                                },
10449
                                editor: {
10450
                                    allowBlank: null_,
10451
                                    xtype: 'datefield',
10452
                                    hideMode: 'visibility',
10453
                                    readOnly: ReadOnly_,
10454
                                    id: tableName + rec.FieldName,
10455
                                    fieldGrid: rec.FieldName,
10456
                                    nameTable: rec.TableName,
10457
                                }
10458
                            });
10459
                            break
10460
                        case "amount":
10461
                            cols.push({
10462
                                xtype: 'minovacurrancycolumn',
10463
                                //renderer: Ext.util.Format.numberRenderer("0,0"),
10464
                                text: rec.HeaderTitle,
10465
                                align: 'right',
10466
                                dataIndex: rec.FieldName,
10467
                                hidden: Hidden_,
10468
                                filter: {
10469
                                    itemDefaults: {
10470
                                        emptyText: 'Search for...'
10471
                                    }
10472
                                },
10473
                                editor: {
10474
                                    allowBlank: null_,
10475
                                    xtype: 'minovacurrencyfield',
10476
                                    //renderer: Ext.util.Format.numberRenderer("0,0"),
10477
                                    //vtype: 'validateDecimal',
10478
                                    readOnly: ReadOnly_,
10479
                                    id: tableName + rec.FieldName,
10480
                                    nameTable: rec.TableName,
10481
                                    fieldGrid: rec.FieldName,
10482
                                    fieldStyle: 'text-align:right;',
10483
                                    value: '0',
10484
									listeners: { //// add by Tri nwh 20220711
10485
										change: function (val, recs) {
10486
											var fvalue = val.getValue();
10487
											var custumFunc = rec.SelectFunction;
10488
											if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
10489
												Ext.Ajax.request({
10490
													async: false,
10491
													method: 'POST',
10492
													url: '/UserControl/GetStore',
10493
													params: {
10494
														tableName: 'PCMFUNC',
10495
														param: 'FuncName[equal]' + custumFunc + ',Active[=]1'
10496
													},
10497
													success: function (response) {
10498
														var results = Ext.decode(response.responseText);
10499
														var dt = results.data[0];
10500
														if (dt != undefined) {
10501
															custumFunc = dt.FunctionCode;
10502
														}
10503
													}
10504
												});
10505
											}
10506
											if (custumFunc) {
10507
												eval(custumFunc)
10508
											}
10509
										}
10510
									}
10511
                                }
10512
                            });
10513
                            break
10514
                        case "time":
10515
                            var DefaultValue = rec.DefaultValue;
10516
                            if (DefaultValue == '') {
10517
                                defaultValue = '00:00';
10518
                            }
10519
                            cols.push({
10520
                                //xtype: 'minovatimecolumn',
10521
                                xtype: 'timefield',
10522
                                format: 'H:i',
10523
                                submitFormat: 'Hi',
10524
                                text: rec.HeaderTitle,
10525
                                dataIndex: rec.FieldName,
10526
                                hidden: Hidden_,
10527
                                //renderer: Ext.util.Format.dateRenderer('G:i'),
10528
                                filter: {
10529
                                    itemDefaults: {
10530
                                        emptyText: 'Search for...'
10531
                                    }
10532
                                },
10533
                                editor: {
10534
                                    allowBlank: null_,
10535
                                    xtype: 'timefield',
10536
                                    readOnly: ReadOnly_,
10537
                                    id: tableName + rec.FieldName,
10538
                                    format: 'H:i',
10539
                                    submitFormat: 'Hi',
10540
                                    increment: 5,
10541
                                    value: DefaultValue,
10542
                                    anchor: '100%',
10543
                                    listeners: {}
10544
                                    //renderer: Ext.util.Format.dateRenderer('G:i'),
10545
                                }
10546
                            });
10547
                            break
10548
                            //case "datetime":
10549
                            //    if (rec.DataRef != 'CREATEDT' && rec.DataRef != 'CHANGEDT') {
10550
                            //        cols.push({
10551
                            //            xtype: 'minovadatetimecolumn',
10552
                            //            text: rec.HeaderTitle,
10553
                            //            dataIndex: rec.FieldName,
10554
                            //            filter: {
10555
                            //                itemDefaults: {
10556
                            //                    emptyText: 'Search for...'
10557
                            //                }
10558
                            //            },
10559
                            //            editor: {
10560
                            //                allowBlank: null_,
10561
                            //                xtype: 'textfield',
10562
                            //            }
10563
                            //        });
10564
                            //    }
10565
                            //    break
10566
                        default:
10567
                            if (rec.DataRef == 'CREATEBY' || rec.DataRef == 'CHANGEBY' || rec.DataRef == 'CREATEDT' || rec.DataRef == 'CHANGEDT') {
10568
                                cols.push({
10569
                                    text: rec.HeaderTitle,
10570
                                    dataIndex: rec.FieldName,
10571
                                    width: 100,
10572
                                    filter: {
10573
                                        type: 'string',
10574
                                        itemDefaults: {
10575
                                            emptyText: 'Search for...'
10576
                                        }
10577
                                    }
10578
                                });
10579
                            } else if (rec.SearchType == '0') {
10580
                                var valueField = null;
10581
                                var displayValue = null;
10582
                                var TableRef = undefined;
10583
                                if (rec.TableRef != '') {
10584
                                    TableRef = rec.TableRef;
10585

    
10586
                                    Ext.Ajax.request({
10587
                                        async: false,
10588
                                        method: 'POST',
10589
                                        url: '/UserControl/GetStore',
10590
                                        params: {
10591
                                            tableName: 'SDATATABLEFIELD',
10592
                                            param: 'TableName[equal]' + rec.TableRef
10593
                                        },
10594
                                        success: function (response) {
10595
                                            var results = Ext.decode(response.responseText);
10596
                                            data_ = results.data;
10597
                                            if (data_ != undefined) {
10598
                                                valueField_ = $.grep(data_, function (r) {
10599
                                                    return r.ValueField == '1'
10600
                                                });
10601
                                                valueField = valueField_[0].FieldName
10602
                                                displayValue_ = $.grep(data_, function (r) {
10603
                                                    return r.DisplayValue == '1'
10604
                                                });
10605
                                                displayValue = displayValue_[0].FieldName
10606
                                            }
10607
                                        }
10608
                                    });
10609

    
10610
                                    //create Store
10611
                                    Ext.create('Ext.data.Store', {
10612
                                        storeId: 'store_' + me.tableName + rec.FieldName,
10613
                                        autoLoad: true,
10614
                                        proxy: {
10615
                                            method: 'POST',
10616
                                            type: 'ajax',
10617
                                            url: '/UserControl/GetStoreAuth',
10618
                                            extraParams: {
10619
                                                tableName: TableRef,
10620
                                                param: rec.ParamCombo,
10621
                                                menuId: MinovaUtil.GetMenuID()
10622
                                            },
10623
                                            reader: {
10624
                                                type: 'json',
10625
                                                root: 'data',
10626
                                                totalProperty: 'data[0].TotalCount'
10627
                                            }
10628
                                        }
10629
                                    });
10630
                                } else if (rec.FixedValue != '') {
10631
                                    var storeData = [];
10632
                                    var str = rec.FixedValue;
10633
                                    var hasil = str.split('||');
10634
                                    hasil.forEach(function (h) {
10635
                                        store_ = h.split('=')
10636
                                        storeData.push({
10637
                                            code: store_[0],
10638
                                            desc: store_[1],
10639

    
10640
                                        });
10641
                                    });
10642

    
10643
                                    valueField = 'code';
10644
                                    displayValue = 'desc';
10645

    
10646
                                    Ext.create('Ext.data.Store', {
10647
                                        storeId: 'store_' + me.tableName + rec.FieldName,
10648
                                        autoLoad: true,
10649
                                        data: storeData
10650
                                    })
10651
                                }
10652

    
10653
                                cols.push({
10654
                                    xtype: 'minovacombocolumn',
10655
                                    hidden: Hidden_,
10656
                                    text: rec.HeaderTitle,
10657
                                    dataIndex: rec.FieldName,
10658
                                    valueField: valueField,
10659
                                    displayField: displayValue,
10660
                                    store: 'store_' + me.tableName + rec.FieldName,
10661
                                    editor: {
10662
                                        allowBlank: null_,
10663
                                        xtype: 'combobox',
10664
                                        readOnly: ReadOnly_,
10665
                                        id: tableName + rec.FieldName,
10666
                                        nameTable: rec.TableName,
10667
                                        fieldGrid: rec.FieldName,
10668
                                        valueField: valueField,
10669
                                        displayField: displayValue,
10670
                                        vtype: 'validateCombobox',
10671
                                        store: 'store_' + me.tableName + rec.FieldName,
10672
                                    },
10673
                                    filter: {
10674
                                        type: 'list',
10675
                                        itemDefaults: {
10676
                                            emptyText: 'Search for...'
10677
                                        }
10678
                                    }
10679
                                });
10680

    
10681
                            } else if (rec.SearchType == '5') {							
10682
                                var valueField = null;
10683
                                var displayValue = null;
10684
                                var AdditionaldisplayValue = null;
10685
                                var TableRef = undefined;
10686
                                if (rec.TableRef != '') {
10687
                                    TableRef = rec.TableRef;
10688
                                    Ext.Ajax.request({
10689
                                        async: false,
10690
                                        method: 'POST',
10691
                                        url: '/UserControl/GetStore',
10692
                                        params: {
10693
                                            tableName: 'SDATATABLEFIELD',
10694
                                            param: 'TableName[equal]' + rec.TableRef
10695
                                        },
10696
                                        success: function (response) {
10697
                                            var results = Ext.decode(response.responseText);
10698
                                            data_ = results.data;
10699
                                            if (data_ != undefined) {
10700
                                                valueField_ = $.grep(data_, function (r) {
10701
                                                    return r.ValueField == '1'
10702
                                                });
10703
                                                if (valueField_.length > 0) {
10704
                                                    valueField = valueField_[0].FieldName
10705
                                                }
10706

    
10707
                                                displayValue_ = $.grep(data_, function (r) {
10708
                                                    return r.DisplayValue == '1' || r.DisplayValue == '2'
10709
                                                });
10710
                                                if (displayValue_.length > 0) {
10711
                                                    displayValue = displayValue_[0].FieldName;
10712
                                                }
10713
                                                if (displayValue_.length >= 2) {
10714
                                                    AdditionaldisplayValue = displayValue_[1].FieldName
10715
                                                }
10716
                                            }
10717
                                        }
10718
                                    });
10719
                                }
10720
                                Ext.create('Ext.data.Store', {
10721
                                    storeId: 'store_' + me.tableName + rec.FieldName,
10722
                                    autoLoad: true,
10723
                                    proxy: {
10724
                                        method: 'POST',
10725
                                        type: 'ajax',
10726
                                        url: '/UserControl/GetStoreAuth',
10727
                                        extraParams: {
10728
                                            tableName: TableRef,
10729
                                            param: rec.ParamCombo,
10730
                                            menuId: MinovaUtil.GetMenuID()
10731
                                        },
10732
                                        reader: {
10733
                                            type: 'json',
10734
                                            root: 'data',
10735
                                            totalProperty: 'data[0].TotalCount'
10736
                                        }
10737
                                    }
10738
                                });
10739
                                cols.push({
10740
                                    xtype : 'minovacombocolumn',
10741
                                    hidden: Hidden_,
10742
                                    text: rec.HeaderTitle,
10743
                                    dataIndex: rec.FieldName,
10744
                                    valueField : valueField,
10745
                                    displayField : displayValue,
10746
                                    store : 'store_' + me.tableName + rec.FieldName,
10747
                                    tpl: Ext.create('Ext.XTemplate',
10748
                                            '<ul class="x-list-plain"><tpl for=".">',
10749
                                            '<li role="option" class="x-boundlist-item">{' + AdditionaldisplayValue + '} - {' + displayValue + '}</li>',
10750
                                            '</tpl></ul>'),
10751
                                    displayTpl: Ext.create('Ext.XTemplate',
10752
                                        '<tpl for=".">',
10753
                                        '{' + AdditionaldisplayValue + '} - {' + displayValue + '}',
10754
                                        '</tpl>'),
10755
                                    editor: {
10756
                                        allowBlank: null_,
10757
                                        xtype: 'combobox',
10758
                                        readOnly: ReadOnly_,
10759
                                        id: rec.TableName + rec.FieldName,
10760
                                        nameTable: rec.TableName,
10761
                                        fieldGrid: rec.FieldName,
10762
                                        valueField: valueField,
10763
                                        displayField: displayValue,
10764
                                        store: 'store_' + me.tableName + rec.FieldName,
10765
                                        value: rec.DefaultValue,
10766
                                        tpl: Ext.create('Ext.XTemplate',
10767
                                            '<ul class="x-list-plain"><tpl for=".">',
10768
                                            '<li role="option" class="x-boundlist-item">{' + AdditionaldisplayValue + '} - {' + displayValue + '}</li>',
10769
                                            '</tpl></ul>'),
10770
                                        displayTpl: Ext.create('Ext.XTemplate',
10771
                                            '<tpl for=".">',
10772
                                            '{' + AdditionaldisplayValue + '} - {' + displayValue + '}',
10773
                                            '</tpl>')
10774
                                    },
10775
                                    renderer: function (value) {
10776
                                        var store = Ext.data.StoreManager.lookup('store_' + me.tableName + rec.FieldName);
10777
                                        var index = store.find(valueField, value);
10778
                                        var val = "";
10779
                                        if (index != -1) {
10780
                                            var rc = store.getAt(index);
10781
                                            //val = rc.get(displayValue);
10782
                                            val = rc.get(AdditionaldisplayValue) + ' - ' + rc.get(displayValue);
10783
                                        } else {
10784
                                            val = value;
10785
                                        }
10786
                                        return val;
10787
                                    },
10788
                                    filter: {
10789
                                        type: 'list',
10790
                                        itemDefaults: {
10791
                                            emptyText: 'Search for...'
10792
                                        }
10793
                                    }
10794
                                });
10795
                            } else if (rec.SearchType == '2') {
10796
                                var triger = (rec.TriggerCombo).split('$');
10797
                                var targetField_ = triger[0];
10798
                                var fieldValue_ = triger[1];
10799
                                cols.push({
10800
                                    text: rec.HeaderTitle,
10801
                                    hidden: Hidden_,
10802
                                    dataIndex: rec.FieldName,
10803
                                    filter: {
10804
                                        itemDefaults: {
10805
                                            emptyText: 'Search for...'
10806
                                        }
10807
                                    },
10808
                                    editor: {
10809
                                        allowBlank: null_,
10810
                                        xtype: 'minovalookupgrid',
10811
                                        readOnly: ReadOnly_,
10812
                                        isGrid: true,
10813
                                        fieldTarget: targetField_,
10814
                                        fieldValue: fieldValue_,
10815
                                        isGrid: true,
10816
                                        id: tableName + rec.FieldName,
10817
                                        tableName: rec.TableRef, //name tabel yang jadi ref-nya
10818
                                        triggerCls: 'x-form-search-trigger',
10819
                                        vtype: 'alphanum', // disable space
10820
                                        nameTable: rec.TableName,
10821
                                        fieldGrid: rec.FieldName,
10822
                                        LookupFunction: rec.LookupFunction,
10823
                                        listeners: {
10824
                                            change: function (val) {
10825
                                                var custumFunc = rec.SelectFunction;
10826
                                                if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
10827
                                                    Ext.Ajax.request({
10828
                                                        async: false,
10829
                                                        method: 'POST',
10830
                                                        url: '/UserControl/GetStore',
10831
                                                        params: {
10832
                                                            tableName: 'PCMFUNC',
10833
                                                            param: 'FuncName[equal]' + rec.custumFunc + ',Active[=]1'
10834
                                                        },
10835
                                                        success: function (response) {
10836
                                                            var results = Ext.decode(response.responseText);
10837
                                                            data_ = results.data[0];
10838
                                                            if (data_ != undefined) {
10839
                                                                custumFunc = data_.FunctionCode;
10840
                                                            }
10841
                                                        }
10842
                                                    });
10843
                                                }
10844
                                                if (custumFunc) {
10845
                                                    eval(custumFunc)
10846
                                                }
10847
                                            }
10848
                                        }
10849
                                    }
10850
                                });
10851
                            } else if (rec.SearchType == '3') {
10852
                                cols.push({
10853
                                    text: rec.HeaderTitle,
10854
                                    hidden: Hidden_,
10855
                                    dataIndex: rec.FieldName,
10856
                                    filter: {
10857
                                        itemDefaults: {
10858
                                            emptyText: 'Search for...'
10859
                                        }
10860
                                    },
10861
                                    editor: {
10862
                                        allowBlank: null_,
10863
                                        // xtype: 'minovalookuptreePopup',
10864
                                        xtype: 'MinovaLookupTree',
10865
                                        readOnly: ReadOnly_,
10866
                                        id: tableName + rec.FieldName,
10867
                                        tableName: rec.TableRef, //name tabel yang jadi ref-nya
10868
                                        triggerCls: 'x-form-search-trigger',
10869
                                        vtype: 'alphanum', // disable space
10870
                                        treeSructure: rec.SearchFunction, //'O-O-P',
10871
                                        objClassValue: rec.ParamCombo, //'O',
10872
                                        nameTable: rec.TableName,
10873
                                        fieldGrid: rec.FieldName,
10874
                                        listeners: {
10875
                                            change: function (val) {
10876
                                                var custumFunc = rec.SelectFunction;
10877
                                                if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
10878
                                                    Ext.Ajax.request({
10879
                                                        async: false,
10880
                                                        method: 'POST',
10881
                                                        url: '/UserControl/GetStore',
10882
                                                        params: {
10883
                                                            tableName: 'PCMFUNC',
10884
                                                            param: 'FuncName[equal]' + rec.custumFunc + ',Active[=]1'
10885
                                                        },
10886
                                                        success: function (response) {
10887
                                                            var results = Ext.decode(response.responseText);
10888
                                                            data_ = results.data[0];
10889
                                                            if (data_ != undefined) {
10890
                                                                custumFunc = data_.FunctionCode;
10891
                                                            }
10892
                                                        }
10893
                                                    });
10894
                                                }
10895
                                                if (custumFunc) {
10896
                                                    eval(custumFunc)
10897
                                                }
10898
                                            }
10899
                                        }
10900
                                    }
10901
                                });
10902
                            } else if (rec.SearchType != '0' && rec.SearchType != '1' && rec.SearchType != '3' && (rec.FieldName == 'EmployeeID' || rec.FieldName == 'ApplicantID' || rec.FieldName == 'EmployeeIDFrom' || rec.FieldName == 'EmployeeIDTo') && isLookup != true) { 
10903
                                var triger = (rec.TriggerCombo).split('&');
10904
                                var targetField_ = triger[0];
10905
                                var fieldValue_ = triger[0];
10906
                                cols.push({
10907
                                    text: rec.HeaderTitle,
10908
                                    hidden: Hidden_,
10909
                                    dataIndex: rec.FieldName,
10910
                                    filter: {
10911
                                        itemDefaults: {
10912
                                            emptyText: 'Search for...'
10913
                                        }
10914
                                    },
10915
                                    editor: {
10916
                                        allowBlank: null_,
10917
                                        xtype: 'lookupemployee',
10918
                                        readOnly: ReadOnly_,
10919
                                        isGrid: true,
10920
                                        fieldTarget: targetField_,
10921
                                        fieldValue: fieldValue_,
10922
                                        isGrid: true,
10923
                                        id: tableName + rec.FieldName,
10924
                                        tableName: rec.TableRef, //name tabel yang jadi ref-nya
10925
                                        triggerCls: 'x-form-search-trigger',
10926
                                        vtype: 'alphanum', // disable space
10927
                                        nameTable: rec.TableName,
10928
                                        fieldGrid: rec.FieldName,
10929
                                        listeners: {
10930
                                            change: function (val) {
10931
                                                var custumFunc = rec.SelectFunction;
10932
                                                if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
10933
                                                    Ext.Ajax.request({
10934
                                                        async: false,
10935
                                                        method: 'POST',
10936
                                                        url: '/UserControl/GetStore',
10937
                                                        params: {
10938
                                                            tableName: 'PCMFUNC',
10939
                                                            param: 'FuncName[equal]' + rec.custumFunc + ',Active[=]1'
10940
                                                        },
10941
                                                        success: function (response) {
10942
                                                            var results = Ext.decode(response.responseText);
10943
                                                            data_ = results.data[0];
10944
                                                            if (data_ != undefined) {
10945
                                                                custumFunc = data_.FunctionCode;
10946
                                                            }
10947
                                                        }
10948
                                                    });
10949
                                                }
10950
                                                if (custumFunc) {
10951
                                                    eval(custumFunc)
10952
                                                }
10953
                                            }
10954
                                        }
10955
                                    }
10956
                                });
10957
                            } else if (rec.SearchType == '4' && isLookup != true) {
10958
                                cols.push({
10959

    
10960
                                    text: rec.HeaderTitle,
10961
                                    hidden: Hidden_,
10962
                                    dataIndex: rec.FieldName,
10963
                                    filter: {
10964
                                        itemDefaults: {
10965
                                            emptyText: 'Search for...'
10966
                                        }
10967
                                    },
10968
                                    editor: {
10969
                                        allowBlank: null_,
10970
                                        xtype: 'lookupemployee',
10971
                                        readOnly: ReadOnly_,
10972
                                        isGrid: true,
10973
                                        fieldTarget: targetField_,
10974
                                        fieldValue: fieldValue_,
10975
                                        isGrid: true,
10976
                                        id: tableName + rec.FieldName,
10977
                                        tableName: rec.TableRef, //name tabel yang jadi ref-nya
10978
                                        triggerCls: 'x-form-search-trigger',
10979
                                        vtype: 'alphanum', // disable space
10980
                                        nameTable: rec.TableName,
10981
                                        fieldGrid: rec.FieldName,
10982
                                        listeners: {
10983
                                            change: function (val) {
10984
                                                var custumFunc = rec.SelectFunction;
10985
                                                if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
10986
                                                    Ext.Ajax.request({
10987
                                                        async: false,
10988
                                                        method: 'POST',
10989
                                                        url: '/UserControl/GetStore',
10990
                                                        params: {
10991
                                                            tableName: 'PCMFUNC',
10992
                                                            param: 'FuncName[equal]' + rec.custumFunc + ',Active[=]1'
10993
                                                        },
10994
                                                        success: function (response) {
10995
                                                            var results = Ext.decode(response.responseText);
10996
                                                            data_ = results.data[0];
10997
                                                            if (data_ != undefined) {
10998
                                                                custumFunc = data_.FunctionCode;
10999
                                                            }
11000
                                                        }
11001
                                                    });
11002
                                                }
11003
                                                if (custumFunc) {
11004
                                                    eval(custumFunc)
11005
                                                }
11006
                                            }
11007
                                        }
11008
                                    }
11009
                                });
11010
                            } else { 
11011
                                if (rec.FieldDataType == 3) { //add by taufan 
11012
                                    cols.push({
11013
                                        text: rec.HeaderTitle,
11014
                                        hidden: Hidden_,
11015
                                        dataIndex: rec.FieldName,
11016
                                        filter: {
11017
                                            itemDefaults: {
11018
                                                emptyText: 'Search for...'
11019
                                            }
11020
                                        },
11021
                                        editor: {
11022
                                            allowBlank: null_,
11023
                                            xtype: 'textfield',
11024
                                            readOnly: ReadOnly_,
11025
                                            id: tableName + rec.FieldName,
11026
                                            nameTable: rec.TableName,
11027
                                            fieldGrid: rec.FieldName,
11028
                                            vtype: 'validateDecimal',
11029
                                            maxLength: rec.Length,
11030
                                            precision: rec.Prec,
11031
                                            fieldStyle: 'text-align:right;',
11032
                                            listeners: {
11033
                                                change: function (val) { 
11034
                                                    var custumFunc = null;
11035
                                                    Ext.Ajax.request({
11036
                                                        async: false,
11037
                                                        method: 'POST',
11038
                                                        url: '/UserControl/GetStore',
11039
                                                        params: {
11040
                                                            tableName: 'SDATATABLEFIELD',
11041
                                                            param: 'FieldName[equal]' + rec.FieldName + ',TableName[equal]' + me.tableName
11042
                                                        },
11043
                                                        success: function (response) { 
11044
                                                            var results = Ext.decode(response.responseText);
11045
                                                            data_ = results.data[0]; 
11046
                                                            if (data_ != undefined) {
11047
                                                                custumFunc = data_.SelectFunction;
11048
                                                                //console.log(data_)
11049
                                                            }
11050
                                                        }
11051
                                                    });
11052

    
11053
                                                    if (custumFunc) {
11054
                                                        eval(custumFunc)
11055
                                                    }
11056
                                                }
11057
                                            }
11058
                                        }
11059
                                    });
11060
                                } else { 
11061
                                    cols.push({
11062
                                        text: rec.HeaderTitle,
11063
                                        hidden: Hidden_,
11064
                                        dataIndex: rec.FieldName,
11065
                                        filter: {
11066
                                            itemDefaults: {
11067
                                                emptyText: 'Search for...'
11068
                                            }
11069
                                        },
11070
                                        editor: {
11071
                                            allowBlank: null_,
11072
                                            xtype: 'textfield',
11073
                                            readOnly: ReadOnly_,
11074
                                            id: tableName + rec.FieldName,
11075
                                            nameTable: rec.TableName,
11076
                                            fieldGrid: rec.FieldName,
11077
                                            listeners: {
11078
                                                change: function (val) { 
11079
                                                    var custumFunc = null;
11080
                                                    Ext.Ajax.request({
11081
                                                        async: false,
11082
                                                        method: 'POST',
11083
                                                        url: '/UserControl/GetStore',
11084
                                                        params: {
11085
                                                            tableName: 'SDATATABLEFIELD',
11086
                                                            param: 'FieldName[equal]' + rec.FieldName + ',TableName[equal]' + me.tableName
11087
                                                        },
11088
                                                        success: function (response) {
11089
                                                            var results = Ext.decode(response.responseText);
11090
                                                            data_ = results.data[0]; 
11091
                                                            if (data_ != undefined) {
11092
                                                                custumFunc = data_.SelectFunction; 
11093
                                                                //console.log(data_)
11094
                                                            }
11095
                                                        }
11096
                                                    });
11097

    
11098
                                                    if (custumFunc) {
11099
                                                        eval(custumFunc)
11100
                                                    }
11101
                                                }
11102
                                            }
11103
                                        }
11104
                                    });
11105
                                }
11106
                            }
11107

    
11108
                            break
11109

    
11110
                    }
11111
                } else {
11112
                    cols.push({
11113
                        text: rec.HeaderTitle,
11114
                        hidden: Hidden_,
11115
                        dataIndex: rec.FieldName,
11116
                        hidden: true,
11117
                        editor: {
11118
                            allowBlank: true,
11119
                            xtype: 'textfield',
11120
                            readOnly: ReadOnly_,
11121
                            id: tableName + rec.FieldName,
11122
                            nameTable: rec.TableName,
11123
                            fieldGrid: rec.FieldName,
11124
                        },
11125
                        filter: {
11126
                            itemDefaults: {
11127
                                emptyText: 'Search for...'
11128
                            }
11129
                        }
11130
                    });
11131
                }
11132
            });
11133

    
11134
        };
11135
        addData = addData + "}";
11136
        Ext.applyIf(me, {
11137
            items: [{
11138
                xtype: 'grid',
11139
                id: gridName,
11140
                name: gridName,
11141
                height: height,
11142
                viewConfig: {
11143
                    emptyText: 'No Data Display',
11144
                    deferEmptyText: false,
11145
                    //Add Nana For Autosize Column Mode
11146
                    listeners: {
11147
                        refresh: function (dataview) {
11148
                            Ext.each(dataview.panel.columns, function (column) {
11149
                                //if (column.autoSizeColumn == false)
11150
                                //	column.autoSizeColumn = true;
11151
                                column.autoSize();
11152
                                //dataview.store.reload();
11153
                            })
11154
                        }
11155
                    },
11156
                    render: function (comp) {
11157
                        comp.getStore().reload();
11158
                        console.log(comp);
11159
                    }
11160
                },
11161
                //store: 'gridStore',
11162
                store: Ext.create('Ext.data.Store', {
11163
                    storeId: storeID,
11164
                    fields: fieldStore,
11165
                    proxy: {
11166
                        method: 'POST',
11167
                        type: 'ajax',
11168
                        url: '',
11169
                        reader: {
11170
                            type: 'json',
11171
                            root: 'data'
11172
                        }
11173
                    }
11174
                }),
11175
                dockedItems: [{
11176
                    xtype: 'toolbar',
11177
                    items: [{
11178
                        text: 'Add',
11179
                        hidden: hide_,
11180
                        name: tableName + 'Add',
11181
                        iconCls: 'fa-plus-circle',
11182
                        style: 'font-family: FontAwesome',
11183
                        handler: function () {
11184
                            var store = Ext.StoreMgr.lookup(storeID)
11185
                            idx = store.getCount();
11186
                            var action = getParam('action');
11187
                            var data = '';
11188
                            var Sequence = 0;
11189
                            if (idx == 0) {
11190
                                Sequence = 1;
11191
                            } else {
11192
                                Sequence = 1 + idx;
11193
                            }
11194
                            //data = {
11195
                            //    Sequence: Sequence
11196
                            //};
11197

    
11198
                            var seq = 'Sequence';
11199
                            var SequenceValue = Sequence;
11200
                            eval(addData);
11201
                            data[seq] = SequenceValue;
11202

    
11203
                            store.insert(idx, data);
11204
                        }
11205

    
11206
                    }, {
11207
                        text: 'Delete',
11208
                        hidden: hide_,
11209
                        name: tableName + 'DeleteText',
11210
                        iconCls: 'fa-trash-o',
11211
                        style: 'font-family: FontAwesome',
11212
                        //disabled: true
11213
                        handler: function () {
11214
                            var me = this,
11215
                            store = Ext.StoreMgr.lookup(storeID)
11216

    
11217
                            var grid = Ext.getCmp(gridName);
11218

    
11219
                            Ext.MessageBox.show({
11220
                                title: 'Remove tab',
11221
                                msg: "This will remove. Do you want to continue?",
11222
                                buttons: Ext.MessageBox.YESNO,
11223
                                fn: function (choice) {
11224
                                    console.log(choice);
11225
                                    if (choice === 'yes') {
11226
                                        var selection = grid.getView().getSelectionModel().getSelection()[0];
11227
                                        if (selection) {
11228
                                            store.remove(selection);
11229
                                        }
11230
                                    }
11231
                                    //delete panel.pendingClose;
11232
                                }
11233
                            });
11234
                        }
11235

    
11236
                    }
11237
                    ]
11238
                }
11239
                ],
11240
                columns: cols,
11241
                selType: checkSelection,
11242
                //selType: 'rowmodel',
11243
                plugins: {
11244
                    ptype: 'rowediting',
11245
                    pluginId: 'rowEditing',
11246
                    clicksToEdit: 0,
11247
                    listeners: {
11248
                        //edit: 'onGridEditorEdit'
11249
                    }
11250
                }
11251
            }, ]
11252

    
11253
        });
11254

    
11255
        me.callParent(arguments);
11256
    }
11257
});
11258

    
11259
Ext.define('MinovaUtil.MinovaES.MinovaCellEditGrid', {
11260
    extend: 'Ext.form.Panel',
11261
    alias: ['widget.MinovaCellEditGrid', 'widget.minovacelleditgrid'],
11262
    requires: [
11263
		'Ext.grid.plugin.CellEditing',
11264
		'Ext.grid.Panel',
11265
    ],
11266

    
11267
    //renderTo: 'panel-extjs',
11268
    anchor: '100%',
11269
    tableName: undefined,
11270
    hideButton: undefined,
11271
    multiSelect: undefined,
11272
    initComponent: function () {
11273
        var me = this;
11274
        var isLookup = me.isLookup;
11275
        var hide_ = false;
11276
        var widthLock = 250;
11277
        var checkSelection = '';
11278

    
11279
        if (me.hideButton == true) {
11280
            hide_ = true;
11281
        }
11282
        if (me.multiSelect) {
11283
            locking = false;
11284
            checkSelection = 'checkboxmodel';
11285
            widthLock = 40;
11286
        }
11287
        var tableName = me.tableName;
11288
        var cols = [];
11289
        var fieldStore = [];
11290
        var _url = 'GetAllField';
11291
        var hasil = null;
11292
        var height = me.height;
11293
        var storeID = 'store' + me.tableName;
11294
        var gridName = 'grid' + me.name;
11295
        if (me.storeName) {
11296
            storeID = me.storeName;
11297
        }
11298
        var LangID = MinovaUtil.GetLangID();
11299
        var parameter = "LangID='" + LangID + "',TableName='" + me.tableName + "'"
11300
        Ext.Ajax.request({
11301
            async: false,
11302
            method: 'POST',
11303
            url: '/UserControl/GetStore',
11304
            params: {
11305
                tableName: 'PDSBS0007',
11306
                param: parameter
11307
            },
11308
            success: function (response) {
11309
                var results = Ext.decode(response.responseText);
11310
                hasil = results.data;
11311
            }
11312
        });
11313
        if (hasil.length > 0) {
11314
            Ext.each(hasil, function (rec) {
11315
                fieldStore.push(rec.FieldName)
11316

    
11317
                var null_ = null;
11318
                var ReadOnly_ = false;
11319
                if (rec.IsPrimaryKey == true) {
11320
                    null_ = false;
11321
                }
11322
                if (rec.IsRequired == true) {
11323
                    null_ = false;
11324
                } else {
11325
                    null_ = true;
11326
                }
11327
                if (rec.ReadOnly == '1') {
11328
                    ReadOnly_ = true;
11329
                }
11330
                var Hidden_ = false;
11331
                if (rec.ReadOnly == '1') {
11332
                    ReadOnly_ = true;
11333
                }
11334

    
11335
                if (rec.IsHidden == '1' || rec.Sequence == '' || rec.Sequence == '0' || rec.ColumnNo == '' || rec.GridView == '') {
11336
                    Hidden_ = true;
11337
                    null_ = true;
11338
                }
11339

    
11340
                if (rec.GridView == 1) {
11341
                    switch (rec.FormatRef) {
11342
                        case "date":
11343
                            cols.push({
11344
                                xtype: 'minovadatecolumn',
11345
                                hidden: Hidden_,
11346
                                text: rec.HeaderTitle,
11347
                                dataIndex: rec.FieldName,
11348
                                filter: {
11349
                                    itemDefaults: {
11350
                                        emptyText: 'Search for...',
11351

    
11352
                                    }
11353
                                },
11354
                                editor: {
11355
                                    allowBlank: null_,
11356
                                    xtype: 'datefield',
11357
                                    hideMode: 'visibility',
11358
                                    readOnly: ReadOnly_,
11359
                                    id: tableName + rec.FieldName,
11360
                                }
11361
                            });
11362
                            break
11363
                        case "amount":
11364
                            cols.push({
11365
                                xtype: 'minovacurrancycolumn',
11366
                                text: rec.HeaderTitle,
11367
                                align: 'right',
11368
                                dataIndex: rec.FieldName,
11369
                                hidden: Hidden_,
11370
                                filter: {
11371
                                    itemDefaults: {
11372
                                        emptyText: 'Search for...'
11373
                                    }
11374
                                },
11375
                                editor: {
11376
                                    allowBlank: null_,
11377
                                    xtype: 'textfield',
11378
                                    readOnly: ReadOnly_,
11379
                                    id: tableName + rec.FieldName,
11380
                                }
11381
                            });
11382
                            break
11383
                            //case "datetime":
11384
                            //    if (rec.DataRef != 'CREATEDT' && rec.DataRef != 'CHANGEDT') {
11385
                            //        cols.push({
11386
                            //            xtype: 'minovadatetimecolumn',
11387
                            //            text: rec.HeaderTitle,
11388
                            //            dataIndex: rec.FieldName,
11389
                            //            filter: {
11390
                            //                itemDefaults: {
11391
                            //                    emptyText: 'Search for...'
11392
                            //                }
11393
                            //            },
11394
                            //            editor: {
11395
                            //                allowBlank: null_,
11396
                            //                xtype: 'textfield',
11397
                            //            }
11398
                            //        });
11399
                            //    }
11400
                            //    break
11401
                        default:
11402
                            if (rec.DataRef == 'CREATEBY' || rec.DataRef == 'CHANGEBY' || rec.DataRef == 'CREATEDT' || rec.DataRef == 'CHANGEDT') {
11403
                                cols.push({
11404
                                    text: rec.HeaderTitle,
11405
                                    dataIndex: rec.FieldName,
11406
                                    width: 100,
11407
                                    filter: {
11408
                                        type: 'string',
11409
                                        itemDefaults: {
11410
                                            emptyText: 'Search for...'
11411
                                        }
11412
                                    }
11413
                                });
11414
                            } else if (rec.SearchType == '0') {
11415
                                var valueField = null;
11416
                                var displayValue = null;
11417
                                var TableRef = undefined;
11418
                                if (rec.TableRef != '') {
11419
                                    TableRef = rec.TableRef;
11420

    
11421
                                    Ext.Ajax.request({
11422
                                        async: false,
11423
                                        method: 'POST',
11424
                                        url: '/UserControl/GetStore',
11425
                                        params: {
11426
                                            tableName: 'SDATATABLEFIELD',
11427
                                            param: 'TableName[equal]' + rec.TableRef
11428
                                        },
11429
                                        success: function (response) {
11430
                                            var results = Ext.decode(response.responseText);
11431
                                            data_ = results.data;
11432
                                            if (data_ != undefined) {
11433
                                                valueField_ = $.grep(data_, function (r) {
11434
                                                    return r.ValueField == '1'
11435
                                                });
11436
                                                valueField = valueField_[0].FieldName
11437
                                                displayValue_ = $.grep(data_, function (r) {
11438
                                                    return r.DisplayValue == '1'
11439
                                                });
11440
                                                displayValue = displayValue_[0].FieldName
11441
                                            }
11442
                                        }
11443
                                    });
11444

    
11445
                                    //create Store
11446
                                    Ext.create('Ext.data.Store', {
11447
                                        storeId: 'store_' + me.tableName + rec.FieldName,
11448
                                        autoLoad: true,
11449
                                        proxy: {
11450
                                            method: 'POST',
11451
                                            type: 'ajax',
11452
                                            url: '/UserControl/GetStoreAuth',
11453
                                            extraParams: {
11454
                                                tableName: TableRef,
11455
                                                param: rec.ParamCombo,
11456
                                                menuId: MinovaUtil.GetMenuID()
11457
                                            },
11458
                                            reader: {
11459
                                                type: 'json',
11460
                                                root: 'data',
11461
                                                totalProperty: 'data[0].TotalCount'
11462
                                            }
11463
                                        }
11464
                                    });
11465

    
11466
                                } else if (rec.FixedValue != '') {
11467
                                    var storeData = [];
11468
                                    var str = rec.FixedValue;
11469
                                    var hasil = str.split('||');
11470
                                    hasil.forEach(function (h) {
11471
                                        store_ = h.split('=')
11472
                                        storeData.push({
11473
                                            code: store_[0],
11474
                                            desc: store_[1],
11475

    
11476
                                        });
11477
                                    });
11478

    
11479
                                    valueField = 'code';
11480
                                    displayValue = 'desc';
11481

    
11482
                                    Ext.create('Ext.data.Store', {
11483
                                        storeId: 'store_' + me.tableName + rec.FieldName,
11484
                                        autoLoad: true,
11485
                                        data: storeData
11486
                                    })
11487
                                }
11488

    
11489
                                cols.push({
11490
                                    xtype: 'minovacombocolumn',
11491
                                    hidden: Hidden_,
11492
                                    text: rec.HeaderTitle,
11493
                                    dataIndex: rec.FieldName,
11494
                                    valueField: valueField,
11495
                                    displayField: displayValue,
11496
                                    store: 'store_' + me.tableName + rec.FieldName,
11497
                                    editor: {
11498
                                        allowBlank: null_,
11499
                                        xtype: 'combobox',
11500
                                        readOnly: ReadOnly_,
11501
                                        id: tableName + rec.FieldName,
11502
                                        valueField: valueField,
11503
                                        displayField: displayValue,
11504
                                        store: 'store_' + me.tableName + rec.FieldName,
11505
                                    },
11506
                                    filter: {
11507
                                        type: 'list',
11508
                                        itemDefaults: {
11509
                                            emptyText: 'Search for...'
11510
                                        }
11511
                                    }
11512
                                });
11513

    
11514
                            } else if (rec.SearchType == '5') {							
11515
                                var valueField = null;
11516
                                var displayValue = null;
11517
                                var AdditionaldisplayValue = null;
11518
                                var TableRef = undefined;
11519
                                if (rec.TableRef != '') {
11520
                                    TableRef = rec.TableRef;
11521
                                    Ext.Ajax.request({
11522
                                        async: false,
11523
                                        method: 'POST',
11524
                                        url: '/UserControl/GetStore',
11525
                                        params: {
11526
                                            tableName: 'SDATATABLEFIELD',
11527
                                            param: 'TableName[equal]' + rec.TableRef
11528
                                        },
11529
                                        success: function (response) {
11530
                                            var results = Ext.decode(response.responseText);
11531
                                            data_ = results.data;
11532
                                            if (data_ != undefined) {
11533
                                                valueField_ = $.grep(data_, function (r) {
11534
                                                    return r.ValueField == '1'
11535
                                                });
11536
                                                if (valueField_.length > 0) {
11537
                                                    valueField = valueField_[0].FieldName
11538
                                                }
11539

    
11540
                                                displayValue_ = $.grep(data_, function (r) {
11541
                                                    return r.DisplayValue == '1' || r.DisplayValue == '2'
11542
                                                });
11543
                                                if (displayValue_.length > 0) {
11544
                                                    displayValue = displayValue_[0].FieldName;
11545
                                                }
11546
                                                if (displayValue_.length >= 2) {
11547
                                                    AdditionaldisplayValue = displayValue_[1].FieldName
11548
                                                }
11549
                                            }
11550
                                        }
11551
                                    });
11552
                                }
11553
                                Ext.create('Ext.data.Store', {
11554
                                    storeId: 'store_' + me.tableName + rec.FieldName,
11555
                                    autoLoad: true,
11556
                                    proxy: {
11557
                                        method: 'POST',
11558
                                        type: 'ajax',
11559
                                        url: '/UserControl/GetStoreAuth',
11560
                                        extraParams: {
11561
                                            tableName: TableRef,
11562
                                            param: rec.ParamCombo,
11563
                                            menuId: MinovaUtil.GetMenuID()
11564
                                        },
11565
                                        reader: {
11566
                                            type: 'json',
11567
                                            root: 'data',
11568
                                            totalProperty: 'data[0].TotalCount'
11569
                                        }
11570
                                    }
11571
                                });
11572
                                cols.push({
11573
                                    xtype : 'minovacombocolumn',
11574
                                    hidden: Hidden_,
11575
                                    text: rec.HeaderTitle,
11576
                                    dataIndex: rec.FieldName,
11577
                                    valueField : valueField,
11578
                                    displayField : displayValue,
11579
                                    store : 'store_' + me.tableName + rec.FieldName,
11580
                                    tpl: Ext.create('Ext.XTemplate',
11581
                                            '<ul class="x-list-plain"><tpl for=".">',
11582
                                            '<li role="option" class="x-boundlist-item">{' + AdditionaldisplayValue + '} - {' + displayValue + '}</li>',
11583
                                            '</tpl></ul>'),
11584
                                    displayTpl: Ext.create('Ext.XTemplate',
11585
                                        '<tpl for=".">',
11586
                                        '{' + AdditionaldisplayValue + '} - {' + displayValue + '}',
11587
                                        '</tpl>'),
11588
                                    editor: {
11589
                                        allowBlank: null_,
11590
                                        xtype: 'combobox',
11591
                                        readOnly: ReadOnly_,
11592
                                        id: rec.TableName + rec.FieldName,
11593
                                        nameTable: rec.TableName,
11594
                                        fieldGrid: rec.FieldName,
11595
                                        valueField: valueField,
11596
                                        displayField: displayValue,
11597
                                        store: 'store_' + me.tableName + rec.FieldName,
11598
                                        value: rec.DefaultValue,
11599
                                        tpl: Ext.create('Ext.XTemplate',
11600
                                            '<ul class="x-list-plain"><tpl for=".">',
11601
                                            '<li role="option" class="x-boundlist-item">{' + AdditionaldisplayValue + '} - {' + displayValue + '}</li>',
11602
                                            '</tpl></ul>'),
11603
                                        displayTpl: Ext.create('Ext.XTemplate',
11604
                                            '<tpl for=".">',
11605
                                            '{' + AdditionaldisplayValue + '} - {' + displayValue + '}',
11606
                                            '</tpl>')
11607
                                    },
11608
                                    renderer: function (value) {
11609
                                        var store = Ext.data.StoreManager.lookup('store_' + me.tableName + rec.FieldName);
11610
                                        var index = store.find(valueField, value);
11611
                                        var val = "";
11612
                                        if (index != -1) {
11613
                                            var rc = store.getAt(index);
11614
                                            //val = rc.get(displayValue);
11615
                                            val = rc.get(AdditionaldisplayValue) + ' - ' + rc.get(displayValue);
11616
                                        } else {
11617
                                            val = value;
11618
                                        }
11619
                                        return val;
11620
                                    },
11621
                                    filter: {
11622
                                        type: 'list',
11623
                                        itemDefaults: {
11624
                                            emptyText: 'Search for...'
11625
                                        }
11626
                                    }
11627
                                });
11628
                            } else if (rec.SearchType == '2') {
11629
                                var triger = (rec.TriggerCombo).split('$');
11630
                                var targetField_ = triger[0];
11631
                                var fieldValue_ = triger[1];
11632
                                cols.push({
11633
                                    text: rec.HeaderTitle,
11634
                                    hidden: Hidden_,
11635
                                    dataIndex: rec.FieldName,
11636
                                    filter: {
11637
                                        itemDefaults: {
11638
                                            emptyText: 'Search for...'
11639
                                        }
11640
                                    },
11641
                                    editor: {
11642
                                        allowBlank: null_,
11643
                                        xtype: 'minovalookupgrid',
11644
                                        readOnly: ReadOnly_,
11645
                                        isGrid: true,
11646
                                        fieldTarget: targetField_,
11647
                                        fieldValue: fieldValue_,
11648
                                        isGrid: true,
11649
                                        id: tableName + rec.FieldName,
11650
                                        tableName: rec.TableRef, //name tabel yang jadi ref-nya
11651
                                        triggerCls: 'x-form-search-trigger',
11652
                                        vtype: 'alphanum', // disable space
11653

    
11654
                                        listeners: {
11655
                                            change: function (val) {
11656
                                                var custumFunc = rec.SelectFunction;
11657
                                                if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
11658
                                                    Ext.Ajax.request({
11659
                                                        async: false,
11660
                                                        method: 'POST',
11661
                                                        url: '/UserControl/GetStore',
11662
                                                        params: {
11663
                                                            tableName: 'PCMFUNC',
11664
                                                            param: 'FuncName[equal]' + rec.custumFunc + ',Active[=]1'
11665
                                                        },
11666
                                                        success: function (response) {
11667
                                                            var results = Ext.decode(response.responseText);
11668
                                                            data_ = results.data[0];
11669
                                                            if (data_ != undefined) {
11670
                                                                custumFunc = data_.FunctionCode;
11671
                                                            }
11672
                                                        }
11673
                                                    });
11674
                                                }
11675
                                                if (custumFunc) {
11676
                                                    eval(custumFunc)
11677
                                                }
11678
                                            }
11679
                                        }
11680
                                    }
11681
                                });
11682
                            } else if (rec.SearchType == '3') {
11683
                                cols.push({
11684
                                    text: rec.HeaderTitle,
11685
                                    hidden: Hidden_,
11686
                                    dataIndex: rec.FieldName,
11687
                                    filter: {
11688
                                        itemDefaults: {
11689
                                            emptyText: 'Search for...'
11690
                                        }
11691
                                    },
11692
                                    editor: {
11693
                                        allowBlank: null_,
11694
                                        // xtype: 'minovalookuptreePopup',
11695
                                        xtype: 'MinovaLookupTree',
11696
                                        readOnly: ReadOnly_,
11697
                                        id: tableName + rec.FieldName,
11698
                                        tableName: rec.TableRef, //name tabel yang jadi ref-nya
11699
                                        triggerCls: 'x-form-search-trigger',
11700
                                        vtype: 'alphanum', // disable space
11701
                                        treeSructure: rec.SearchFunction, //'O-O-P',
11702
                                        objClassValue: rec.ParamCombo, //'O',
11703
                                        listeners: {
11704
                                            change: function (val) {
11705
                                                var custumFunc = rec.SelectFunction;
11706
                                                if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
11707
                                                    Ext.Ajax.request({
11708
                                                        async: false,
11709
                                                        method: 'POST',
11710
                                                        url: '/UserControl/GetStore',
11711
                                                        params: {
11712
                                                            tableName: 'PCMFUNC',
11713
                                                            param: 'FuncName[equal]' + rec.custumFunc + ',Active[=]1'
11714
                                                        },
11715
                                                        success: function (response) {
11716
                                                            var results = Ext.decode(response.responseText);
11717
                                                            data_ = results.data[0];
11718
                                                            if (data_ != undefined) {
11719
                                                                custumFunc = data_.FunctionCode;
11720
                                                            }
11721
                                                        }
11722
                                                    });
11723
                                                }
11724
                                                if (custumFunc) {
11725
                                                    eval(custumFunc)
11726
                                                }
11727
                                            }
11728
                                        }
11729
                                    }
11730
                                });
11731
                            } else if (rec.SearchType != '0' && rec.SearchType != '1' && rec.SearchType != '3' && (rec.FieldName == 'EmployeeID' || rec.FieldName == 'ApplicantID' || rec.FieldName == 'EmployeeIDFrom' || rec.FieldName == 'EmployeeIDTo') && isLookup != true) {
11732
                                var triger = (rec.TriggerCombo).split('&');
11733
                                var targetField_ = triger[0];
11734
                                var fieldValue_ = triger[0];
11735
                                cols.push({
11736
                                    text: rec.HeaderTitle,
11737
                                    hidden: Hidden_,
11738
                                    dataIndex: rec.FieldName,
11739
                                    filter: {
11740
                                        itemDefaults: {
11741
                                            emptyText: 'Search for...'
11742
                                        }
11743
                                    },
11744
                                    editor: {
11745
                                        allowBlank: null_,
11746
                                        xtype: 'lookupemployee',
11747
                                        readOnly: ReadOnly_,
11748
                                        isGrid: true,
11749
                                        fieldTarget: targetField_,
11750
                                        fieldValue: fieldValue_,
11751
                                        isGrid: true,
11752
                                        id: tableName + rec.FieldName,
11753
                                        tableName: rec.TableRef, //name tabel yang jadi ref-nya
11754
                                        triggerCls: 'x-form-search-trigger',
11755
                                        vtype: 'alphanum', // disable space
11756
                                        listeners: {
11757
                                            change: function (val) {
11758
                                                var custumFunc = rec.SelectFunction;
11759
                                                if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
11760
                                                    Ext.Ajax.request({
11761
                                                        async: false,
11762
                                                        method: 'POST',
11763
                                                        url: '/UserControl/GetStore',
11764
                                                        params: {
11765
                                                            tableName: 'PCMFUNC',
11766
                                                            param: 'FuncName[equal]' + rec.custumFunc + ',Active[=]1'
11767
                                                        },
11768
                                                        success: function (response) {
11769
                                                            var results = Ext.decode(response.responseText);
11770
                                                            data_ = results.data[0];
11771
                                                            if (data_ != undefined) {
11772
                                                                custumFunc = data_.FunctionCode;
11773
                                                            }
11774
                                                        }
11775
                                                    });
11776
                                                }
11777
                                                if (custumFunc) {
11778
                                                    eval(custumFunc)
11779
                                                }
11780
                                            }
11781
                                        }
11782
                                    }
11783
                                });
11784
                            } else if (rec.SearchType == '4' && isLookup != true) {
11785
                                cols.push({
11786

    
11787
                                    text: rec.HeaderTitle,
11788
                                    hidden: Hidden_,
11789
                                    dataIndex: rec.FieldName,
11790
                                    filter: {
11791
                                        itemDefaults: {
11792
                                            emptyText: 'Search for...'
11793
                                        }
11794
                                    },
11795
                                    editor: {
11796
                                        allowBlank: null_,
11797
                                        xtype: 'lookupemployee',
11798
                                        readOnly: ReadOnly_,
11799
                                        isGrid: true,
11800
                                        fieldTarget: targetField_,
11801
                                        fieldValue: fieldValue_,
11802
                                        isGrid: true,
11803
                                        id: tableName + rec.FieldName,
11804
                                        tableName: rec.TableRef, //name tabel yang jadi ref-nya
11805
                                        triggerCls: 'x-form-search-trigger',
11806
                                        vtype: 'alphanum', // disable space
11807
                                        listeners: {
11808
                                            change: function (val) {
11809
                                                var custumFunc = rec.SelectFunction;
11810
                                                if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
11811
                                                    Ext.Ajax.request({
11812
                                                        async: false,
11813
                                                        method: 'POST',
11814
                                                        url: '/UserControl/GetStore',
11815
                                                        params: {
11816
                                                            tableName: 'PCMFUNC',
11817
                                                            param: 'FuncName[equal]' + rec.custumFunc + ',Active[=]1'
11818
                                                        },
11819
                                                        success: function (response) {
11820
                                                            var results = Ext.decode(response.responseText);
11821
                                                            data_ = results.data[0];
11822
                                                            if (data_ != undefined) {
11823
                                                                custumFunc = data_.FunctionCode;
11824
                                                            }
11825
                                                        }
11826
                                                    });
11827
                                                }
11828
                                                if (custumFunc) {
11829
                                                    eval(custumFunc)
11830
                                                }
11831
                                            }
11832
                                        }
11833
                                    }
11834
                                });
11835
                            } else {
11836
                                cols.push({
11837
                                    text: rec.HeaderTitle,
11838
                                    hidden: Hidden_,
11839
                                    dataIndex: rec.FieldName,
11840
                                    filter: {
11841
                                        itemDefaults: {
11842
                                            emptyText: 'Search for...'
11843
                                        }
11844
                                    },
11845
                                    editor: {
11846
                                        allowBlank: null_,
11847
                                        xtype: 'textfield',
11848
                                        readOnly: ReadOnly_,
11849
                                        id: tableName + rec.FieldName,
11850
                                        listeners: {
11851
                                            change: function (val) {
11852
                                                var custumFunc = null;
11853
                                                Ext.Ajax.request({
11854
                                                    async: false,
11855
                                                    method: 'POST',
11856
                                                    url: '/UserControl/GetStore',
11857
                                                    params: {
11858
                                                        tableName: 'SDATATABLEFIELD',
11859
                                                        param: 'FieldName[equal]' + rec.FieldName + ',TableName[equal]' + me.tableName
11860
                                                    },
11861
                                                    success: function (response) {
11862
                                                        var results = Ext.decode(response.responseText);
11863
                                                        data_ = results.data[0];
11864
                                                        if (data_ != undefined) {
11865
                                                            custumFunc = data_.SelectFunction;
11866
                                                            //console.log(data_)
11867
                                                        }
11868
                                                    }
11869
                                                });
11870

    
11871
                                                if (custumFunc) {
11872
                                                    eval(custumFunc)
11873
                                                }
11874
                                            }
11875
                                        }
11876
                                    }
11877
                                });
11878
                            }
11879

    
11880
                            break
11881

    
11882
                    }
11883
                } else {
11884
                    cols.push({
11885
                        text: rec.HeaderTitle,
11886
                        hidden: Hidden_,
11887
                        dataIndex: rec.FieldName,
11888
                        hidden: true,
11889
                        editor: {
11890
                            allowBlank: true,
11891
                            xtype: 'textfield',
11892
                            readOnly: ReadOnly_,
11893
                            id: tableName + rec.FieldName,
11894
                        },
11895
                        filter: {
11896
                            itemDefaults: {
11897
                                emptyText: 'Search for...'
11898
                            }
11899
                        }
11900
                    });
11901
                }
11902
            });
11903
        };
11904

    
11905
        this.cellEditing = new Ext.grid.plugin.CellEditing({
11906
            clicksToEdit: 1
11907
        });
11908
        Ext.applyIf(me, {
11909
            items: [{
11910
                xtype: 'grid',
11911
                id: gridName,
11912
                name: gridName,
11913
                height: height,
11914
                //store: 'gridStore',
11915
                store: Ext.create('Ext.data.Store', {
11916
                    storeId: storeID,
11917
                    fields: fieldStore,
11918
                    proxy: {
11919
                        method: 'POST',
11920
                        type: 'ajax',
11921
                        url: '',
11922
                        reader: {
11923
                            type: 'json',
11924
                            root: 'data'
11925
                        }
11926
                    }
11927
                }),
11928
                viewConfig: {
11929
                    emptyText: 'No Data Display',
11930
                    deferEmptyText: false,
11931
                    //Add Nana For Autosize Column Mode
11932
                    listeners: {
11933
                        refresh: function (dataview) {
11934
                            Ext.each(dataview.panel.columns, function (column) {
11935
                                if (column.autoSizeColumn == false)
11936
                                    column.autoSizeColumn = true;
11937
                                column.autoSize();
11938
                                //dataview.store.reload();
11939
                            })
11940
                        }
11941
                    },
11942
                    render: function (comp) {
11943
                        comp.getStore().reload();
11944
                        console.log(comp);
11945
                    }
11946
                },
11947
                dockedItems: [{
11948
                    xtype: 'toolbar',
11949
                    items: [{
11950
                        text: 'Add',
11951
                        hidden: hide_,
11952
                        name: tableName + 'Add',
11953
                        iconCls: 'fa-plus-circle',
11954
                        style: 'font-family: FontAwesome',
11955
                        handler: function () {
11956
                            var store = Ext.StoreMgr.lookup(storeID)
11957
                            idx = store.getCount();
11958
                            var action = getParam('action');
11959
                            var data = '';
11960
                            var Sequence = 0;
11961
                            if (idx == 0) {
11962
                                Sequence = 1;
11963
                            } else {
11964
                                Sequence = 1 + idx;
11965
                            }
11966
                            data = {
11967
                                Sequence: Sequence
11968
                            };
11969

    
11970
                            store.insert(idx, data);
11971
                        }
11972

    
11973
                    }, {
11974
                        text: 'Delete',
11975
                        hidden: hide_,
11976
                        name: tableName + 'DeleteText',
11977
                        iconCls: 'fa-trash-o',
11978
                        style: 'font-family: FontAwesome',
11979
                        //disabled: true
11980
                        handler: function () {
11981
                            var me = this,
11982
                            store = Ext.StoreMgr.lookup(storeID)
11983

    
11984
                            var grid = Ext.getCmp(gridName);
11985

    
11986
                            Ext.MessageBox.show({
11987
                                title: 'Remove tab',
11988
                                msg: "This will remove. Do you want to continue?",
11989
                                buttons: Ext.MessageBox.YESNO,
11990
                                fn: function (choice) {
11991
                                    console.log(choice);
11992
                                    if (choice === 'yes') {
11993
                                        var selection = grid.getView().getSelectionModel().getSelection()[0];
11994
                                        if (selection) {
11995
                                            store.remove(selection);
11996
                                        }
11997
                                    }
11998
                                    //delete panel.pendingClose;
11999
                                }
12000
                            });
12001
                        }
12002

    
12003
                    }
12004
                    ]
12005
                }
12006
                ],
12007
                columns: cols,
12008
                selModel: {
12009
                    type: 'cellmodel'
12010
                },
12011
                plugins: [this.cellEditing],
12012
            }, ]
12013

    
12014
        });
12015

    
12016
        me.callParent(arguments);
12017
    }
12018
});
12019
//hamid200916
12020
Ext.define('MinovaUtil.MinovaES.MinovaLookupEmployeelama', {
12021
    extend: 'Ext.panel.Panel',
12022
    alias: 'widget.lookupemployeelama',
12023
	height: '35%',
12024
    requires: [
12025
		'Ext.data.*',
12026
		'Ext.grid.*',
12027
		'Ext.tree.*',
12028
		'Ext.ux.CheckColumn',
12029
		//'MinovaES.View.sample.samplepopupEMPID'
12030

    
12031
    ],
12032
    formname: undefined,
12033
    fieldname: undefined,
12034
    allowBlank: undefined,
12035
    width: undefined,
12036
    tableName: undefined,
12037
    //bodyStyle: 'padding-left: -20px; padding-bottom: -20px; padding-top: -20px; padding-right: -20px;',
12038
    //padding: '-40px',
12039
    //bodyStyle: 'margin:-20px;',
12040
    //margin: '-20 -20 -20 -20',
12041
    //fieldLabel: undefined,
12042
    //name: undefined,
12043
    //pnl: this.name,
12044
    initComponent: function () {
12045
        var me = this;
12046
        targetField_ = me.fieldname;
12047
        //var nameField_ = me.name;
12048
        //var panelform = this.pnl;
12049
        var nameField_ = me.fieldname;
12050
        var blank = me.allowBlank;
12051
        var width_ = me.width;
12052
        var tableName_ = me.tableName;
12053
        var panelform = "form" + me.name;
12054
        //var fieldLabel_ = me.fieldLabel;
12055
        Ext.applyIf(me, {
12056
            items: [{
12057
                xtype: 'form',
12058
                name: panelform,
12059
                items: [{
12060
                    xtype: 'fieldcontainer',
12061
                    layout: 'hbox',
12062
                    fieldLabel: me.fieldLabel,
12063
                    items: [{
12064
                        xtype: "triggerfield",
12065
                        name: nameField_,
12066
                        width: width_,
12067
                        //anchor: '50%',
12068
                        //editable: true,
12069
                        allowBlank: blank,
12070
                        triggerCls: 'x-form-search-trigger',
12071
                        onTriggerClick: function (e) {
12072
                            //var tableName_ = this.tableName;
12073
                            var count_lookup = Ext.ComponentQuery.query('[name=popup_lookupEMPID]').length;
12074
                            var lookupEMPID = Ext.ComponentQuery.query('[name=popup_lookupEMPID]')[0];
12075
                            var EmployeeID = Ext.ComponentQuery.query('[name=' + nameField_ + ']')[0];
12076
                            var EmployeeID_ = EmployeeID.getValue();
12077
                            //var params = "EmployeeID[=]" + EmployeeID.getValue();
12078
                            //var Url = "sample?EmployeeID=" + EmployeeID.getValue();
12079
                            //window.open(Url, "_self");
12080
                            //var selection_ = selection.getValue();
12081
                            //var EmployeeSearch = Ext.ComponentQuery.query('[name=EmployeeSearch]')[0];
12082
                            //var lokup = EmployeeSearch.setValue(selection_);
12083

    
12084
                            var popup_lookupEMPID = Ext.ComponentQuery.query('[name=popup_lookupEMPID]').length;
12085
                            if (count_lookup == 1) {
12086
                                Ext.ComponentQuery.query('[name=popup_lookupEMPID]')[0].targetField = this.name;
12087
                                Ext.ComponentQuery.query('[name=popup_lookupEMPID]')[0].show();
12088
                            } else {
12089
                                //var _popUploadView = Ext.create("MinovaUtil.MinovaES.LookupEmployeeQuickSearch");
12090
                                Ext.create('MinovaUtil.MinovaES.LookupEmployeeQuickSearch', {
12091
                                    //    tableName: tableName_,
12092

    
12093
                                    //}).show()
12094
                                    //_popUploadView.tableName = tableName_;
12095
                                    tableName: tableName_,
12096
                                    targetField: this.name,
12097
                                }).show()
12098
                            }
12099

    
12100
                            //var _popUploadView = Ext.create("MinovaES.view.sample.samplepopupEMPID");
12101
                            //var a = _popUploadView.show();
12102
                            var text = Ext.ComponentQuery.query('[name=EmployeeSearch]')[0];
12103
                            text.setValue(EmployeeID_);
12104

    
12105
                            if (EmployeeID_ !== "") {
12106
                                var store = Ext.data.StoreManager.lookup('lookupEMPID');
12107
                                var grid = Ext.ComponentQuery.query('[name=' + nameField_ + ']')[0];
12108
                                store.proxy.extraParams = {
12109
                                    tableName: tableName_, //'PDSEMP0002',
12110
                                    param: 'EmpID_ExternalID_FullName[like]' + EmployeeID_
12111
                                };
12112
                                store.reload();
12113
                            }
12114
                        },
12115
                        listeners: {
12116
                            specialkey: function (f, e) {
12117
                                if (e.getKey() == e.ENTER) {
12118
                                    //alert("about to submit");
12119
                                    var count_lookup = Ext.ComponentQuery.query('[name=popup_lookupEMPID]').length;
12120
                                    var lookupEMPID = Ext.ComponentQuery.query('[name=popup_lookupEMPID]')[0];
12121
                                    var EmployeeID = Ext.ComponentQuery.query('[name=' + nameField_ + ']')[0];
12122
                                    var EmployeeID_ = EmployeeID.getValue();
12123

    
12124
                                    var popup_lookupEMPID = Ext.ComponentQuery.query('[name=popup_lookupEMPID]').length;
12125
                                    if (count_lookup == 1) {
12126
                                        Ext.ComponentQuery.query('[name=popup_lookupEMPID]')[0].targetField = this.name;
12127
                                        Ext.ComponentQuery.query('[name=popup_lookupEMPID]')[0].show();
12128
                                    } else {
12129
                                        Ext.create('MinovaUtil.MinovaES.LookupEmployeeQuickSearch', {
12130
                                            tableName: tableName_,
12131
                                            targetField: this.name,
12132
                                        }).show()
12133
                                        //var _popUploadView = Ext.create("MinovaUtil.MinovaES.LookupEmployeeQuickSearch");
12134
                                        //_popUploadView.targetField = this.name;
12135
                                        //_popUploadView.show();
12136

    
12137
                                    }
12138
                                    //var _popUploadView = Ext.create("MinovaES.view.sample.samplepopupEMPID");
12139
                                    //var a = _popUploadView.show();
12140
                                    var text = Ext.ComponentQuery.query('[name=EmployeeSearch]')[0];
12141
                                    text.setValue(EmployeeID_);
12142

    
12143
                                    if (EmployeeID_ !== "") {
12144
                                        var store = Ext.data.StoreManager.lookup('lookupEMPID');
12145
                                        var grid = Ext.ComponentQuery.query('[name=' + nameField_ + ']')[0];
12146
                                        store.proxy.extraParams = {
12147
                                            tableName: tableName_, //'PDSEMP0002',
12148
                                            param: 'EmpID_ExternalID_FullName[like]' + EmployeeID_
12149
                                        };
12150
                                        store.reload();
12151
                                    }
12152
                                    //myform.getForm().submit();
12153
                                }
12154
                            }
12155
                        }
12156

    
12157
                    }, {
12158
                        xtype: 'tbspacer',
12159
                        width: 5
12160
                    }, {
12161
                        xtype: 'button',
12162
                        name: nameField_,
12163
                        anchor: '50%',
12164
                        text: 'Advance',
12165
                        listeners: {
12166
                            click: function () {
12167
                                var count_lookup = Ext.ComponentQuery.query('[name=popup_lookupEmployee]').length;
12168
                                if (count_lookup == 1) {
12169
                                    Ext.ComponentQuery.query('[name=popup_lookupEmployee]')[0].targetField = this.name;
12170
                                    Ext.ComponentQuery.query('[name=popup_lookupEmployee]')[0].show();
12171
                                } else {
12172
                                    Ext.create('MinovaUtil.MinovaES.LookupEmployeeAdvance', {
12173
                                        tableName: tableName_,
12174
                                        targetField: this.name,
12175
                                    }).show()
12176
                                    //var _popUploadView = Ext.create("MinovaUtil.MinovaES.LookupEmployeeAdvance");
12177
                                    //_popUploadView.targetField = this.name;
12178
                                    //_popUploadView.show();
12179

    
12180
                                }
12181
                            }
12182
                        },
12183
                    }
12184
                    ]
12185
                }
12186
                ]
12187
            }
12188
            ]
12189
        });
12190
        me.callParent(arguments);
12191
    }
12192
});
12193

    
12194
Ext.define('MinovaUtil.MinovaES.LookupEmployeeQuickSearch', {
12195
    extend: 'Ext.window.Window',
12196
    alias: 'widget.popup_employeequicksearch',
12197
    requires: [
12198
		// 'MinovaES.controller.sample.ctrlsample',
12199
		//'MinovaES.store.data.TableType',
12200
    ],
12201
    //controller: 'ctrlsample',
12202
    height: '85%',
12203
    width: '42%',
12204
    minWidth: '50%',
12205
    maxWidth: '100%',
12206
    bodyPadding: 0,
12207
    formname: undefined,
12208
    //modal: true,
12209
    title: 'Lookup - EmployeeID',
12210
    name: 'popup_lookupEMPID',
12211
    test: undefined,
12212
    targetField: undefined,
12213
    tableName: undefined,
12214
    afterender: function () {
12215
        test = nameform;
12216
    },
12217
    initComponent: function () {
12218

    
12219
        var me = this;
12220
        var targetField_ = me.targetField;
12221
        var form = me.test;
12222
        var tableName_ = me.tableName;
12223
        Ext.applyIf(me, {
12224
            items: [{
12225
                xtype: 'form',
12226
                name: 'frmSearch',
12227
                width: '100%',
12228
                height: 'auto',
12229
                dockedItems: [{
12230
                    xtype: 'toolbar',
12231
                    dock: 'top',
12232
                    layout: 'vbox',
12233
                    bodyPadding: 10,
12234
                    border: 0,
12235
                    items: [{
12236
                        xtype: 'fieldset',
12237
                        layout: 'hbox',
12238
                        width: '100%',
12239
                        border: 0,
12240
                        padding: 0,
12241
                        items: [{
12242
                            xtype: 'textfield',
12243
                            name: 'EmployeeSearch',
12244
                            fieldLabel: 'Emp ID/ External ID/ Full Name',
12245
                            width: 475,
12246
                            labelWidth: 185,
12247
                            enableKeyEvents: true,
12248
                            listeners: {
12249
                                specialkey: function (f, e) {
12250
                                    if (e.getKey() == e.ENTER) {
12251
                                        var emp = Ext.ComponentQuery.query('[name=EmployeeSearch]')[0];
12252
                                        var emp_ = emp.getValue();
12253
                                        var store = Ext.data.StoreManager.lookup('lookupEMPID');
12254
                                        var grid = Ext.ComponentQuery.query('[name=EmployeeID]')[0];
12255
                                        store.proxy.extraParams = {
12256
                                            tableName: tableName_, //'PDSEMP0002',
12257
                                            param: 'EmpID_ExternalID_FullName[like]' + emp_
12258
                                        };
12259
                                        store.reload();
12260
                                    }
12261
                                }
12262
                            }
12263
                        }, {
12264
                            xtype: 'tbspacer',
12265
                            width: 5
12266
                        }, {
12267
                            xtype: 'button',
12268
                            name: 'Search',
12269
                            text: 'Search',
12270
                            handler: function () {
12271
                                var emp = Ext.ComponentQuery.query('[name=EmployeeSearch]')[0];
12272
                                var emp_ = emp.getValue();
12273
                                var store = Ext.data.StoreManager.lookup('lookupEMPID');
12274
                                var grid = Ext.ComponentQuery.query('[name=EmployeeID]')[0];
12275
                                store.proxy.extraParams = {
12276
                                    tableName: tableName_, //'PDSEMP0002',
12277
                                    param: 'EmpID_ExternalID_FullName[like]' + emp_
12278
                                };
12279
                                store.reload();
12280
                            },
12281

    
12282
                        }
12283
                        ]
12284
                    }
12285
                    ]
12286
                }
12287
                ],
12288
            }, {
12289
                items: [{
12290
                    xtype: "minovagrid1",
12291
                    name: "GridEmployeeID",
12292
                    storename: 'lookupEMPID',
12293
                    tableName: tableName_, //'PDSEMP0002',
12294
                    param: '',
12295
                    isLookup: true,
12296
                    pagesize: 25,
12297
                    height: 425,
12298
                    listeners: {
12299
                        beforeedit: function () {
12300
                            return false;
12301
                        },
12302
                        itemdblclick: function () {
12303
                            var grid = Ext.ComponentQuery.query('[name=GridEmployeeID]')[0];
12304
                            var selection = grid.getView().getSelectionModel().getSelection()[0];
12305
                            var Emp_ = selection.data.EmployeeID;
12306
                            //var formSelection = Ext.ComponentQuery.query('[name=' + form + ']')[0];
12307
                            //formSelection.getForm().setValues(grid.getSelectionModel().getSelection()[0].data);
12308

    
12309
                            var target = Ext.ComponentQuery.query('[name=popup_lookupEMPID]')[0].targetField;
12310
                            Ext.ComponentQuery.query('[name=' + target + ']')[0].setValue(Emp_);
12311
                            //Ext.ComponentQuery.query('[name=EmployeeiD]')[0].setValue(selection.data.EmployeeID);;
12312
                            Ext.ComponentQuery.query('[name=popup_lookupEMPID]')[0].hide();
12313
                        }
12314
                    },
12315
                }, {
12316
                    xtype: 'pagingtoolbar',
12317
                    store: 'lookupEMPID',
12318
                    dock: 'bottom',
12319
                    displayInfo: true
12320
                }
12321
                ]
12322
            }
12323
            ]
12324
        });
12325
        me.callParent(arguments);
12326
    }
12327
});
12328
Ext.define('MinovaUtil.MinovaES.LookupEmployeeAdvance', {
12329
    extend: 'Ext.window.Window',
12330
    alias: 'widget.popup_employeeadvance',
12331
    requires: [
12332
		//'MinovaES.controller.sample.ctrlsample',
12333
		//'MinovaES.store.data.TableType',
12334
    ],
12335
    //controller: 'ctrlsample',
12336
    height: '85%',
12337
    width: '42%',
12338
    minWidth: '50%',
12339
    maxWidth: '100%',
12340
    bodyPadding: 10,
12341
    anchor: '50%',
12342
    formname: undefined,
12343
    //modal: true,
12344
    title: 'Lookup - EmployeeID',
12345
    name: 'popup_lookupEmployee',
12346
    test: undefined,
12347
    targetField: undefined,
12348
    tableName: undefined,
12349
    initComponent: function () {
12350
        var me = this;
12351
        var targetField_ = me.targetField;
12352
        var form = me.test;
12353
        var tableName_ = me.tableName;
12354
        Ext.applyIf(me, {
12355
            items: [{
12356
                xtype: 'form',
12357
                name: 'formlookup',
12358
                items: [{
12359
                    xtype: 'minovaform',
12360
                    name: 'frmlookup',
12361
                    tableName: tableName_, //'PDSEMP0001',
12362
                    param: '',
12363
                    isLookup: true,
12364
                    listeners: {
12365
                        onStockFormKeyPress: function (textfield, event, options) {
12366
                            if (event.getKey() == event.ENTER) {
12367
                                alert("test");
12368
                                //Ext.Msg.alert('Keys', 'You pressed the Enter key');
12369
                            }
12370
                        }
12371
                    },
12372
                    buttons: [{
12373
                        text: 'Search',
12374
                        //iconCls : 'fa-edit',
12375
                        //style : 'font-family: FontAwesome',
12376
                        listeners: {
12377
                            click: function () {
12378
                                var store = Ext.data.StoreManager.lookup('lookupStore');
12379
                                var form = Ext.ComponentQuery.query('[name=formlookup]')[0].getForm();
12380
                                grid = Ext.ComponentQuery.query('[name=gridlookup]')[0];
12381
                                var values_ = form.getValues();
12382
                                var fields_ = form.getFields().items;
12383
                                var param_ = '';
12384
                                for (var i = 0; i < fields_.length; i++) {
12385
                                    var val_ = form.getFields().items[i].getValue();
12386
                                    var xtype_ = form.getFields().items[i].xtype;
12387
                                    var oprator_ = '[like]';
12388
                                    if (xtype_ == 'combobox' || xtype_ == 'combo' || xtype_ == 'minovacombo' || xtype_ == 'minovacombobox') {
12389
                                        oprator_ = '[Equal]';
12390
                                    }
12391
                                    if (xtype_ == 'datefield') {
12392
                                        if (form.getFields().items[i].name == 'StartDate' || form.getFields().items[i].name == 'ValidForm') {
12393
                                            oprator_ = '[LessThanEqual]';
12394
                                        } else {
12395
                                            oprator_ = '[GreaterThanEqual]';
12396
                                        }
12397
                                    }
12398
                                    if (val_ != 'undefined' && val_ != "" && val_ != null) {
12399
                                        param_ = param_ + ',' + form.getFields().items[i].name + oprator_ + val_;
12400
                                    }
12401
                                }
12402
                                store.proxy.extraParams = {
12403
                                    tableName: grid.tableName,
12404
                                    param: param_
12405
                                };
12406
                                store.removeAll();
12407
                                store.reload();
12408
                                store.loadPage(1);
12409
                            },
12410

    
12411
                        }
12412
                    }
12413
                    ]
12414
                }, {
12415
                    xtype: 'minovagrid',
12416
                    name: 'gridlookup',
12417
                    minHeight: 320,
12418
                    height: 250,
12419
                    tableName: tableName_, //'PDSEMP0001',
12420
                    param: '',
12421
                    isLookup: true,
12422
                    storename: 'lookupStore',
12423
                    pagesize: 25,
12424
                    listeners: {
12425
                        beforeedit: function () {
12426
                            return false;
12427
                        },
12428
                        itemdblclick: function () {
12429
                            var grid = Ext.ComponentQuery.query('[name=gridlookup]')[0];
12430
                            var selection = grid.getView().getSelectionModel().getSelection()[0];
12431
                            var Emp_ = selection.data.EmployeeID;
12432
                            //var formSelection = Ext.ComponentQuery.query('[name=EmployeeSelection]')[0];
12433
                            //formSelection.getForm().setValues(grid.getSelectionModel().getSelection()[0].data);
12434
                            var target = Ext.ComponentQuery.query('[name=popup_lookupEmployee]')[0].targetField;
12435
                            Ext.ComponentQuery.query('[name=' + target + ']')[0].setValue(Emp_);
12436
                            Ext.ComponentQuery.query('[name=popup_lookupEmployee]')[0].hide();
12437

    
12438
                        }
12439
                    },
12440
                    dockedItems: [{
12441
                        xtype: 'pagingtoolbar',
12442
                        store: 'lookupStore',
12443
                        dock: 'bottom',
12444
                        displayInfo: true
12445
                    }
12446
                    ]
12447
                }
12448
                ]
12449
            }
12450
            ]
12451
        });
12452
        me.callParent(arguments);
12453
    }
12454
});
12455
//end hamid
12456

    
12457

    
12458
// lookup tree
12459
Ext.define('MinovaES.view.orm.lookup.minovalookuptreePopup', {
12460
    extend: 'Ext.window.Window',
12461
    alias: 'widget.minovalookuptreePopup',
12462
    requires: [
12463

    
12464
    ],
12465
    height: '50%',
12466
    width: '40%',
12467
    minWidth: '50%',
12468
    maxWidth: '100%',
12469
    bodyPadding: 5,
12470
    modal: true,
12471
    name: 'mainlookupTree',
12472
    objFilter: undefined,
12473
    treeSructure: undefined, // object relationship
12474
    objClassValue: undefined, // object yang akan di input ke field
12475
    formname: undefined, // nama form
12476
    targetField: undefined, // nama field yang akan diset value
12477
    //title:'judul',
12478
    bodyPadding: 0,
12479
    initComponent: function () {
12480
        var me = this;
12481
        var objFilter_ = me.objFilter;
12482
        var treeSructure_ = me.treeSructure;
12483
        var formname_ = me.formname;
12484
        var objClassValue_ = me.objClassValue;
12485
        var targetField_ = me.targetField;
12486
        var AllObjectClass = treeSructure_.split('-');
12487
        var form_ = Ext.ComponentQuery.query('[name=' + formname_ + ']')[0];
12488
        var StartDate_ = '';
12489
        if (form_) {
12490

    
12491
            if (form_.getForm().findField('StartDate')) {
12492
                StartDate_ = form_.getForm().findField('StartDate').getValue();
12493
            } else {
12494
                StartDate_ = MinovaUtil.GetNowDate();
12495
            }
12496

    
12497
        }
12498

    
12499
        Ext.applyIf(me, {
12500
            items: [{
12501
                //xtype : 'panel',
12502
                items: [{
12503
                    xtype: 'tabpanel',
12504
                    items: [{
12505

    
12506
                        xtype: 'form',
12507
                        title: 'Structured Search',
12508
                        height: '70%',
12509
                        tabConfig: {
12510
                            tooltip: 'Search by tree'
12511
                        },
12512
                        items: [{
12513
                            xtype: 'form',
12514
                            items: [{
12515

    
12516
                                xtype: 'treepanel',
12517
                                rootVisible: false,
12518
                                height: 400,
12519

    
12520
                                name: 'searchByTreePopUp',
12521
                                useArrows: true,
12522
                                animate: false,
12523
                                targetField: targetField_,
12524
                                formname: formname_,
12525
                                root: {
12526
                                    expanded: true,
12527
                                    nodeType: 'async',
12528
                                    ext: 'Favorites',
12529
                                    id: 'null'
12530
                                },
12531
                                listeners: {
12532
                                    afterrender: function (me_) {
12533
                                        me_.mask();
12534
                                        if (treeSructure_ != 'O-O-P') {
12535
                                            var countCol = me_.columns.length;
12536
                                            me_.columns[countCol - 1].setHidden(true);
12537

    
12538
                                        }
12539
                                        if (StartDate_ != '') {
12540
                                            var node = "root";
12541
                                            var ObjectClass_ = treeSructure_.split('-');
12542
                                            //Ext.Ajax.request({
12543
                                            //    method: 'POST',
12544
                                            //    async: false,
12545
                                            //    url: '/UserControl/GetStoreAuth',
12546
                                            //    params: {
12547
                                            //        tableName: "PHROM0001",
12548
                                            //        param: "ObjectClass[=]" + ObjectClass_[0],
12549
                                            //        menuId: MinovaUtil.GetMenuID()
12550
                                            //    },
12551
                                            //    success: function (response) {
12552
                                            //        var results = Ext.decode(response.responseText);
12553
                                            //        var data_ = results.data;
12554
                                            //        if (data_.length > 0 && data_.length == 1) {
12555
                                            //            node = ObjectClass_[0] + data_[0].ObjectID;
12556
                                            //        }
12557

    
12558
                                            //    }
12559
                                            //});
12560

    
12561
                                            Ext.Ajax.request({
12562
                                                async: false,
12563
                                                //url: '/ORM/GetRelObjectTreeAsync?node=' + node + '&tree_struct_code=' + treeSructure_ + '&keyDate=' + StartDate_,
12564
                                                url: '/ORM/GetRelObjectTreeAsyncAuth?node=' + 'root' + '&tree_struct_code=' + treeSructure_ + '&keyDate=' + StartDate_ + '&ObjectClass=' + ObjectClass_[0] + '&MenuID=' + /*MinovaUtil.GetMenuID()*/'PM01',
12565
                                                success: function (response) {
12566
                                                    var results = Ext.decode(response.responseText);
12567
                                                    var data_ = results.results;
12568
                                                    //console.log(data_)
12569
                                                    var pnl = Ext.ComponentQuery.query('[name=searchByTreePopUp]')[0];
12570
                                                    pnl.store.setRootNode({
12571
                                                        expanded: true,
12572
                                                        nodetype: 'async',
12573
                                                        children: data_
12574
                                                        //[]
12575
                                                    });
12576
                                                }
12577
                                            });
12578

    
12579
                                        }
12580
                                        me_.unmask();
12581
                                    },
12582
                                    afteritemexpand: function (node, index, item, eOpts) {
12583
                                        var me = this;
12584
                                        var data_ = null;
12585
                                        var idx = 0;
12586
                                        var tree_ = Ext.ComponentQuery.query('treepanel[name=searchByTreePopUp]')[0];
12587
                                        var v = tree_.getView();
12588
                                        tree_.mask('Expanding tree...');
12589
                                        var main_ = Ext.ComponentQuery.query('[name=ORMMain]')[0];
12590
                                        Ext.Ajax.request({
12591
                                            async: false,
12592
                                            url: '/ORM/GetRelObjectTreeAsync?node=' + node.get('Id') + '&tree_struct_code=' + treeSructure_ + '&keyDate=' + StartDate_,
12593
                                            success: function (response) {
12594
                                                var results = Ext.decode(response.responseText);
12595
                                                data_ = results.results;
12596
                                                console.log(data_)
12597
												tree_.unmask(); //YN 20220418
12598
                                            }
12599
                                        });
12600

    
12601
                                        if (data_.length > 0) {
12602
                                            data_.forEach(function (rec) {
12603

    
12604
                                                //console.log(rec.Id)
12605
                                                if (v.store.data.find('Id', rec.Id) == null) {
12606
                                                    node.appendChild(data_[idx])
12607
                                                }
12608
                                                idx++;
12609
                                            })
12610
                                        }
12611

    
12612
										//YN 20220418
12613
                                        //setTimeout(function () {
12614

    
12615
                                            //tree_.unmask();
12616
                                        //}, 200);
12617

    
12618
                                    },
12619
                                    itemdblclick: function (this_, record, item, index, e, eOpts) {
12620
                                        var cek = false;
12621
                                        var class_ = objClassValue_;
12622
                                        var classDt = class_.split(']');
12623
                                        var classVal = "";
12624
                                        if (classDt.length == 1) {
12625
                                            classVal = classDt[0];
12626
                                        }
12627
                                        if (classDt.length > 1) {
12628
                                            classVal = classDt[1];
12629
                                        }
12630
                                        if (classVal == record.data.ObjectType) {
12631
                                            var form_ = Ext.ComponentQuery.query('[name=' + formname_ + ']')[0].getForm();
12632
                                            var type = 'rc';
12633
                                            if (form_.findField(targetField_).nameTable) {
12634
                                                type = form_.findField(targetField_).nameTable.substr(3, 2).toLowerCase();
12635
                                            }
12636
                                            if (type != "rc") {
12637
                                                if (classVal == 'P' && (MinovaUtil.GetMenuID() == 'PA02' || MinovaUtil.GetMenuID() == 'ESS_MUTATION' || MinovaUtil.GetMenuID() == 'ESS_PROMOTION')) {
12638
                                                    // cek apakah posisis sudah di assign
12639
                                                    var hasil = null;
12640
                                                    Ext.Ajax.request({
12641
                                                        async: false,
12642
                                                        method: 'POST',
12643
                                                        url: '/UserControl/GetStore',
12644
                                                        params: {
12645
                                                            tableName: 'PHROM0002',
12646
                                                            param: 'ObjectClass[=]P,RelationshipDirectory[=]A,RelationshipClass[=]E,StartDate[LessThanEqual]' + StartDate_ + ',EndDate[GreaterThanEqual]' + StartDate_ + ',ObjectID[=]' + record.data.ObjectId
12647
                                                        },
12648
                                                        success: function (response) {
12649
                                                            var results = Ext.decode(response.responseText);
12650
                                                            //hasil = results.data[0].RelationshipObject;
12651
                                                            hasil = results.data.length;
12652
                                                            if (hasil == 0) {
12653
                                                                cek = true;
12654
                                                            } else {
12655
                                                                //Ext.Msg.show({
12656
                                                                //    title: 'Warning',
12657
                                                                //    message: MinovaMessageData('OM0001', ''),
12658
                                                                //    buttons: Ext.Msg.OK,
12659
                                                                //     fn: function (choice) {
12660
                                                                //        console.log(choice);
12661
                                                                //        if (choice === 'ok') {
12662
                                                                //        }
12663

    
12664
                                                                //    }
12665
                                                                //});
12666
                                                                //alert(MinovaMessageData('OM0001', ''))
12667
																MinovaMessageError("Position Occupied", "OM0001", "");
12668
                                                            }
12669
                                                            //count = hasil.length
12670
                                                        }
12671
                                                    });
12672
                                                } else {
12673
                                                    cek = true;
12674
                                                }
12675
                                            } else {
12676
                                                cek = true;
12677
                                            }
12678
                                        }
12679
                                        if (cek) {
12680
                                            // set value to form
12681
                                            var form_ = Ext.ComponentQuery.query('[name=' + formname_ + ']')[0].getForm();
12682
                                            form_.findField(targetField_).setValue('a');
12683
                                            form_.findField(targetField_).valData = 'a';
12684
                                            form_.findField(targetField_).setValue(record.data.Text);
12685
                                            form_.findField(targetField_).valData = record.data.ObjectId;
12686
                                            form_.findField(targetField_).focus();
12687
                                            if (form_.findField(targetField_).nextSibling()) {
12688
                                                form_.findField(targetField_).nextSibling().focus();
12689
                                            } else {
12690
                                                form_.findField(targetField_).blur();
12691
                                            }
12692
                                            Ext.ComponentQuery.query('[name=' + targetField_ + 'lookUp' + ']')[0].destroy();
12693
                                        }
12694

    
12695
                                    }
12696
                                },
12697

    
12698
                                columns: [{
12699
                                    xtype: 'treecolumn',
12700
                                    text: 'Organization Structure',
12701
                                    flex: 2,
12702
                                    sortable: true,
12703
                                    dataIndex: 'TextObject'
12704
                                }, {
12705
                                    text: 'Object ID',
12706
                                    flex: 1,
12707
                                    sortable: true,
12708
                                    dataIndex: 'ObjectId',
12709
                                }, {
12710
                                    text: 'Object Class',
12711
                                    flex: 1,
12712
                                    sortable: true,
12713
                                    dataIndex: 'ObjectType',
12714
                                }, {
12715
                                    text: 'Object Abbr',
12716
                                    flex: 1,
12717
                                    sortable: true,
12718
                                    dataIndex: 'TextObject',
12719
                                }, {
12720
                                    text: 'Start Date',
12721
                                    flex: 1,
12722
                                    sortable: true,
12723
                                    dataIndex: 'StartDate',
12724
                                }, {
12725
                                    text: 'End Date',
12726
                                    flex: 1,
12727
                                    sortable: true,
12728
                                    dataIndex: 'EndDate',
12729
                                }, {
12730
                                    xtype: 'actioncolumn',
12731
                                    text: 'Vacant Status',
12732
                                    flex: 1,
12733
                                    dataIndex: 'IsVacant',
12734
                                    sortable: true,
12735
                                    iconCls: 'fa-child',
12736
                                    renderer: function (value, metadata, record) {
12737
                                        if (record.data.ObjectType == "P") {
12738
                                            var Vacant = record.data.IsVacant;
12739
                                            if (!Vacant) {
12740
                                                metadata.tdStyle = 'font-family: FontAwesome';
12741
                                            }
12742

    
12743
                                        }
12744

    
12745
                                    },
12746
                                }
12747
                                ]
12748

    
12749
                            }
12750
                            ]
12751
                        }
12752
                        ]
12753
                    }, {
12754
                        title: 'Search by Object',
12755
                        height: 400,
12756
                        autoScroll: true,
12757
                        items: [{
12758
                            xtype: 'form',
12759
                            name: 'filterbyObj',
12760
                            margin: '5 5 5 5',
12761
                            buttons: [{
12762
                                text: 'Search',
12763
                                name: 'SearchAssign',
12764
                                handler: function () {
12765
                                    var storeGrid = Ext.StoreMgr.lookup("gridObj");
12766
                                    var form = Ext.ComponentQuery.query('[name=filterbyObj]')[0].getForm();
12767
                                    if (form.isValid()) {
12768
                                        var values_ = form.getValues();
12769
                                        storeGrid.proxy.url = '/ORM/SearchByObject?StartDate=' + values_.StartDate + "&EndDate=99991231" + "&ObjectID=" + values_.ObjectID + "&ObjectClass=" + values_.ObjectClass +
12770
                                            "&ObjectClassTarget=" + values_.ObjectClassTarget + "&ObjectDescription=" + values_.ObjectDescription +
12771
                                            "&Abbreviation=" + values_.Abbreviation + "&MenuID=" + MinovaUtil.GetMenuID() +
12772
                                            "&TreeStructCode=" + values_.TreeStructCode;
12773
                                        storeGrid.load({});
12774
                                        storeGrid.loadPage(1);
12775

    
12776
                                    }
12777

    
12778
                                }
12779
                            }
12780
                            ],
12781
                            items: [{
12782
                                xtype: "datefield",
12783
                                fieldLabel: "Date",
12784
                                name: 'StartDate',
12785
                                submitFormat: 'Ymd',
12786
                                format: 'd/m/Y',
12787
                                value: new Date(),
12788
                                anchor: '50%',
12789
                            }, {
12790
                                xtype: "hidden",
12791
                                fieldLabel: "Date",
12792
                                name: 'ObjectClass',
12793
                                value: AllObjectClass[0],
12794
                                anchor: '50%',
12795
                            }, {
12796
                                xtype: "hidden",
12797
                                fieldLabel: "Date",
12798
                                name: 'EndDate',
12799
                                value: '99991231',
12800
                                anchor: '50%',
12801
                            }, {
12802
                                xtype: "combobox",
12803
                                fieldLabel: "Object Class",
12804
                                name: 'ObjectClassTarget',
12805
                                allowBlank: false,
12806
                                anchor: '50%',
12807
                                displayField: 'desc',
12808
                                valueField: 'code',
12809
                                store: Ext.create('Ext.data.Store', {
12810
                                    storeId: 'storeYesNo',
12811
                                    fields: ['code', 'desc'],
12812
                                    data: [{
12813
                                        "desc": AllObjectClass[0],
12814
                                        "code": AllObjectClass[0]
12815
                                    }, {
12816
                                        "desc": AllObjectClass[2],
12817
                                        "code": AllObjectClass[2]
12818
                                    }
12819
                                    ]
12820
                                }),
12821
                                queryMode: 'local',
12822
                            }, {
12823
                                xtype: "textfield",
12824
                                fieldLabel: "Object ID",
12825
                                name: 'ObjectID',
12826
                                anchor: '50%',
12827
                            }, {
12828
                                xtype: "textfield",
12829
                                fieldLabel: "Object Description",
12830
                                name: 'ObjectDescription',
12831
                                anchor: '50%',
12832
                            }, {
12833
                                xtype: "textfield",
12834
                                fieldLabel: "Abbreviation",
12835
                                name: 'Abbreviation',
12836
                                anchor: '50%',
12837
                            }, {
12838
                                xtype: "hidden",
12839
                                fieldLabel: "MenuID",
12840
                                name: 'MenuID',
12841
                                anchor: '50%',
12842
                                value: MinovaUtil.GetMenuID()
12843
                            }, {
12844
                                xtype: "hidden",
12845
                                fieldLabel: "TreeStructCode",
12846
                                name: 'TreeStructCode',
12847
                                anchor: '50%',
12848
                                value: treeSructure_
12849
                            },
12850
                            ],
12851
                        }, {
12852
                            xtype: "minovagrid1",
12853
                            tableName: 'PDSBS0008',
12854
                            name: "gridbyObject",
12855
                            param: '',
12856
                            autoLoad: false,
12857
                            pagesize: 5,
12858
                            storename: 'gridObj',
12859
                            isLookup: true,
12860
                            height: 250,
12861
                            targetField: targetField_,
12862
                            formname: formname_,
12863
                            bodyPadding: 0,
12864
                            listeners: {
12865
                                afterrender: function (me_) {
12866
                                    if (treeSructure_ != 'O-O-P') {
12867
                                        var countCol = me_.columns.length;
12868
                                        me_.columns[countCol - 1].setHidden(true);
12869

    
12870
                                    }
12871
                                },
12872
                                itemdblclick: function (this_, record, item, index, e, eOpts) {
12873
                                    console.log(record.data);
12874
                                    var cek = false;
12875
                                    if (objClassValue_ == record.data.ObjectClass) {
12876
                                        var form_ = Ext.ComponentQuery.query('[name=' + formname_ + ']')[0].getForm();
12877
                                        if (form_.findField(targetField_).nameTable.substr(3, 2).toLowerCase() != "rc") {
12878
                                            if (objClassValue_ == 'P') {
12879
                                                // cek apakah posisis sudah di assign
12880
                                                var hasil = null;
12881
                                                Ext.Ajax.request({
12882
                                                    async: false,
12883
                                                    method: 'POST',
12884
                                                    url: '/UserControl/GetStore',
12885
                                                    params: {
12886
                                                        tableName: 'PHROM0002',
12887
                                                        param: 'ObjectClass[=]P,RelationshipDirectory[=]A,RelationshipClass[=]E,StartDate[GreaterThanEqual]' + StartDate_ + ',ObjectID[=]' + record.data.ObjectID
12888
                                                    },
12889
                                                    success: function (response) {
12890
                                                        var results = Ext.decode(response.responseText);
12891
                                                        //hasil = results.data[0].RelationshipObject;
12892
                                                        hasil = results.data.length;
12893
                                                        if (hasil == 0) {
12894
                                                            cek = true;
12895
                                                        }
12896
                                                        //count = hasil.length
12897
                                                    }
12898
                                                });
12899

    
12900
                                            } else {
12901
                                                cek = true;
12902
                                            }
12903
                                        } else {
12904
                                            cek = true;
12905
                                        }
12906
                                    }
12907
                                    if (cek) {
12908
                                        var form_ = Ext.ComponentQuery.query('[name=' + formname_ + ']')[0].getForm();
12909
                                        //form_.findField(targetField_).setValue(record.data.ObjectID);
12910
                                        //form_.findField(targetField_).valData = record.data.ObjectID + ' - ' + record.data.ObjectDescription;
12911
                                        form_.findField(targetField_).setValue('-');
12912
                                        form_.findField(targetField_).valData = '-';
12913
                                        form_.findField(targetField_).setValue(record.data.ObjectID);
12914
                                        form_.findField(targetField_).valData = record.data.ObjectID;
12915
                                        form_.findField(targetField_).setRawValue(record.data.ObjectID + ' - ' + record.data.ObjectDescription);
12916
                                        Ext.ComponentQuery.query('[name=' + targetField_ + 'lookUp' + ']')[0].destroy();
12917
                                    } else {
12918
                                        alert(MinovaMessageData('OM0001', ''))
12919
                                    }
12920
                                },
12921
                                beforeclick: function () {
12922
                                    return false;
12923
                                }
12924

    
12925
                            },
12926
                            dockedItems: [{
12927
                                xtype: 'pagingtoolbar',
12928
                                store: 'gridObj',
12929
                                dock: 'bottom',
12930
                                displayInfo: true
12931
                            }
12932

    
12933
                            ]
12934
                        },
12935
                        ]
12936

    
12937
                    }
12938
                    ]
12939

    
12940
                }
12941
                ]
12942
            },
12943
            ]
12944

    
12945
        });
12946
        me.callParent(arguments);
12947
    }
12948
});
12949

    
12950
Ext.define('MinovaUtil.MinovaES.MinovaLookupTree', {
12951
    extend: 'Ext.form.field.Trigger',
12952
    alias: ['widget.minovalookuptree', 'widget.MinovaLookupTree'],
12953
    treeSructure: undefined, // object relationship
12954
    objClassValue: undefined, // object yang akan di input ke field
12955
    formname: undefined, // nama form
12956
    targetField: undefined, // nama field yang akan diset value
12957
    initComponent: function () {
12958

    
12959
        this.callParent();
12960
    },
12961
    getValue: function () {
12962
        var me = this;
12963
        var hasil = '';
12964
        if (this.valData) {
12965
            hasil = this.valData.split('-')[0].replace(' ', '');
12966

    
12967
        } else {
12968
            if (me.rawValue != '' && me.rawValue != undefined) {
12969
                hasil = me.rawValue.split('-')[0].replace(' ', '');
12970
            }
12971
        }
12972

    
12973
        return hasil;
12974
    },
12975
    getSubmitValue: function () {
12976
        var me = this;
12977
        var hasil = '';
12978
        if (this.valData) {
12979
            hasil = this.valData.split('-')[0].replace(' ', '');
12980
        } else {
12981
            if (me.rawValue != '' && me.rawValue != undefined) {
12982
                hasil = me.rawValue.split('-')[0].replace(' ', '');
12983
            }
12984
        }
12985

    
12986
        return hasil;
12987
    },
12988
    onTriggerClick: function () {
12989
        var _treeSructure = this.treeSructure;
12990
        var _objClassValue = this.objClassValue;
12991
        var _formname = this.formname;
12992
        var _targetField = this.name;
12993
        var _fieldLabel = this.fieldLabel;
12994
        var _objFilter = this.objFilter;
12995
        var Mainform = Ext.ComponentQuery.query('[name=' + _formname + ']')[0];
12996
        var _StartDate = MinovaUtil.GetNowDate();
12997
        if (Mainform) {
12998
            if (Mainform.getForm().findField('StartDate')) {
12999
                _StartDate = Mainform.getForm().findField('StartDate').getValue();
13000
            }
13001
        }
13002
        //alert(treeSructure_ + ',' + objClassValue_ + ',' + formname_ + ',' + targetField_)
13003
        if (_StartDate != "") {
13004
            Ext.create('MinovaES.view.orm.lookup.minovalookuptreePopup', {
13005
                name: _targetField + 'lookUp',
13006
                treeSructure: _treeSructure, // object relationship
13007
                objClassValue: _objClassValue, // object yang akan di input ke field
13008
                formname: _formname, // nama form
13009
                targetField: _targetField,
13010
                objFilter: _objFilter,
13011
                title: 'Lookup ' + _fieldLabel
13012
            }).show()
13013
        } else {
13014
            MinovaMessage('', 'BS0001', 'Start Date', 'E')
13015
        }
13016

    
13017
    },
13018
});
13019

    
13020
Ext.define('MinovaUtil.MinovaES.LookupEmployee', {
13021
    extend: 'Ext.window.Window',
13022
    alias: 'widget.minovalookupemployee',
13023
    requires: [],
13024
    height: '35%',
13025
    width: '41%',
13026
    minWidth: '50%',
13027
    maxWidth: '100%',
13028
    bodyPadding: 0,
13029
    formname: undefined,
13030
    name: 'popup_lookupEMPID',
13031
    test: undefined,
13032
    vtype: 'validateMinovaXss',
13033
    targetField: undefined,
13034
    valueField: undefined,
13035
    tableName: undefined,
13036
    LookupFunction: undefined,
13037
    isGrid: undefined,
13038
    listeners: {
13039
        afterrender: function (f) {
13040
            f.setTitle('Lookup - ' + f.targetField);
13041
        }
13042
    },
13043
    initComponent: function () {
13044
        var me = this;
13045
        var targetField_ = me.targetField;
13046
        var valueField_ = me.valueField;
13047
        var form = me.test;
13048
        var tableName_ = me.tableName;
13049
        var isGrid = me.isGrid_;
13050
        var LookupFunction = me.LookupFunction;
13051
        param_ = null;
13052

    
13053
        var filterParam_ = me.filterParam;
13054
        if (tableName_ == "PDSRC0002") {
13055
            fieldLabel_ = 'App ID/ External ID/ Full Name';
13056
        } else {
13057
            fieldLabel_ = 'Emp ID/ External ID/ Full Name';
13058
        }
13059
        Ext.applyIf(me, {
13060
            items: [{
13061
                items: [{
13062
                    xtype: 'tabpanel',
13063
                    items: [{
13064
                        xtype: 'form',
13065
                        title: 'Quick Search',
13066
                        height: '70%',
13067
                        items: [{
13068
                            xtype: 'form',
13069
                            name: 'frmSearch',
13070
                            width: '100%',
13071
                            height: 'auto',
13072
                            dockedItems: [{
13073
                                xtype: 'toolbar',
13074
                                dock: 'top',
13075
                                layout: 'vbox',
13076
                                bodyPadding: 10,
13077
                                border: 0,
13078
                                items: [{
13079
                                    xtype: 'fieldset',
13080
                                    layout: 'hbox',
13081
                                    width: '100%',
13082
                                    border: 0,
13083
                                    padding: 0,
13084
                                    items: [{
13085
                                        xtype: 'textfield',
13086
                                        name: 'EmployeeSearch',
13087
                                        fieldLabel: fieldLabel_,
13088
                                        width: 470,
13089
                                        labelWidth: 185,
13090
                                        enableKeyEvents: true,
13091
                                        filterParam: filterParam_,
13092
                                        listeners: {
13093
                                            specialkey: function (f, e) {
13094
                                                if (e.getKey() == e.ENTER) {
13095
                                                    var emp = Ext.ComponentQuery.query('[name=EmployeeSearch]')[0];
13096
                                                    var emp_ = emp.getValue();
13097
                                                    var store = Ext.data.StoreManager.lookup('storeQC');
13098
                                                    var grid = Ext.ComponentQuery.query('[name=EmployeeID]')[0];
13099
                                                    if (tableName_ == 'PDSRC0002') {
13100
                                                        param_ = 'AppIDExternalIDFullName[like]' + emp_
13101
                                                    } else {
13102
                                                        param_ = 'EmpIDExternalIDFullName[like]' + emp_
13103
                                                    }
13104
                                                    if (this.filterParam) {
13105
                                                        param_ = param_ + ',' + this.filterParam_
13106
                                                    }
13107

    
13108
                                                    store.proxy.extraParams = {
13109
                                                        tableName: tableName_,
13110
                                                        param: param_,
13111
                                                        menuId: MinovaUtil.GetMenuID()
13112
                                                    };
13113
                                                    store.removeAll();
13114
                                                    store.reload();
13115
                                                    store.loadPage(1);
13116
                                                }
13117
                                            }
13118
                                        }
13119
                                    }, {
13120
                                        xtype: 'tbspacer',
13121
                                        width: 5
13122
                                    }, {
13123
                                        xtype: 'button',
13124
                                        name: 'Search',
13125
                                        text: 'Search',
13126
                                        filterParam: filterParam_,
13127
                                        handler: function () {
13128
                                            var emp = Ext.ComponentQuery.query('[name=EmployeeSearch]')[0];
13129
                                            var emp_ = emp.getValue();
13130
                                            var store = Ext.data.StoreManager.lookup('storeQC');
13131
                                            var grid = Ext.ComponentQuery.query('[name=EmployeeID]')[0];
13132

    
13133
                                            if (tableName_ == 'PDSRC0002') {
13134
                                                param_ = 'AppIDExternalIDFullName[like]' + emp_
13135
                                            } else {
13136
                                                param_ = 'EmpIDExternalIDFullName[like]' + emp_
13137
                                            }
13138
                                            if (this.filterParam) {
13139
                                                param_ = param_ + ',' + this.filterParam
13140
                                            }
13141
                                            store.proxy.extraParams = {
13142
                                                tableName: tableName_,
13143
                                                param: param_,
13144
                                                menuId: MinovaUtil.GetMenuID()
13145
                                            };
13146
                                            store.removeAll();
13147
                                            store.reload();
13148
                                            store.loadPage(1);
13149
                                        }
13150
                                    }
13151
                                    ]
13152
                                }
13153
                                ]
13154
                            }
13155
                            ]
13156
                        }, {
13157
                            items: [{
13158
                                xtype: "minovagrid1",
13159
                                name: "GridEmployeeID",
13160
                                storename: 'storeQC',
13161
                                tableName: tableName_,
13162
                                param: '',
13163
                                isLookup: true,
13164
                                pagesize: 25,
13165
                                height: 398,
13166
                                LookupFunction: LookupFunction,
13167
                                valueField: valueField_,
13168
                                targetField: targetField_,
13169
                                isGrid: true,
13170
                                listeners: {
13171
                                    beforeedit: function () {
13172
                                        return false;
13173
                                    },
13174
                                    itemdblclick: function () {
13175
                                        var grid = Ext.ComponentQuery.query('[name=GridEmployeeID]')[0];
13176
                                        var selection = grid.getView().getSelectionModel().getSelection()[0];
13177
                                        var Emp_ = selection.data.EmployeeID;
13178
                                        LookupFunction = this.LookupFunction;
13179
                                        eval(LookupFunction);
13180
                                        var target = Ext.ComponentQuery.query('[name=popup_lookupEMPID]')[0].targetField;
13181
                                        Ext.ComponentQuery.query('[name=' + target + ']')[0].setValue(Emp_);
13182
                                        Ext.ComponentQuery.query('[name=popup_lookupEMPID]')[0].hide();
13183
                                    }
13184
                                },
13185
                            }, {
13186
                                xtype: 'pagingtoolbar',
13187
                                store: 'storeQC',
13188
                                dock: 'bottom',
13189
                                displayInfo: true
13190
                            }
13191
                            ]
13192
                        }
13193
                        ]
13194
                    }, {
13195
                        title: 'Advance Search',
13196
                        items: [{
13197
                            xtype: 'form',
13198
                            name: 'formlookup',
13199
                            items: [{
13200
                                xtype: 'minovaform',
13201
                                name: 'frmlookup',
13202
                                tableName: tableName_,
13203
                                param: filterParam_,
13204
                                isLookup: true,
13205
                                listeners: {
13206
                                    onStockFormKeyPress: function (textfield, event, options) {
13207
                                        if (event.getKey() == event.ENTER) {
13208
                                            alert("test");
13209
                                        }
13210
                                    }
13211
                                },
13212
                                buttons: [{
13213
                                    text: 'Search',
13214
                                    filterParam: filterParam_,
13215
                                    listeners: {
13216
                                        click: function () {
13217
                                            var store = Ext.data.StoreManager.lookup('storeadvance');
13218
                                            var form = Ext.ComponentQuery.query('[name=formlookup]')[0].getForm();
13219
                                            grid = Ext.ComponentQuery.query('[name=gridlookup]')[0];
13220
                                            var values_ = form.getValues();
13221
                                            var fields_ = form.getFields().items;
13222
                                            var param_ = '';
13223
                                            for (var i = 0; i < fields_.length; i++) {
13224
                                                var val_ = form.getFields().items[i].getValue();
13225
                                                var xtype_ = form.getFields().items[i].xtype;
13226
                                                var oprator_ = '[like]';
13227
                                                if (xtype_ == 'combobox' || xtype_ == 'combo' || xtype_ == 'minovacombo' || xtype_ == 'minovacombobox') {
13228
                                                    oprator_ = '[Equal]';
13229
                                                }
13230
                                                if (xtype_ == 'datefield') {
13231
                                                    if (form.getFields().items[i].name == 'StartDate' || form.getFields().items[i].name == 'ValidForm') {
13232
                                                        oprator_ = '[LessThanEqual]';
13233
                                                    } else {
13234
                                                        oprator_ = '[GreaterThanEqual]';
13235
                                                    }
13236
                                                }
13237
                                                if (val_ != 'undefined' && val_ != "" && val_ != null) {
13238
                                                    param_ = param_ + ',' + form.getFields().items[i].name + oprator_ + val_;
13239
                                                }
13240
                                            }
13241
                                            if (this.filterParam_) {
13242
                                                param_ = param_ + ',' + this.filterParam_
13243
                                            }
13244
                                            store.proxy.extraParams = {
13245
                                                tableName: grid.tableName,
13246
                                                param: param_,
13247
                                                menuId: MinovaUtil.GetMenuID()
13248
                                            };
13249
                                            store.removeAll();
13250
                                            store.reload();
13251
                                            store.loadPage(1);
13252
                                        },
13253

    
13254
                                    }
13255
                                }
13256
                                ]
13257
                            }, {
13258
                                xtype: 'minovagrid1', // update by hamid 20170208
13259
                                name: 'gridlookup',
13260
                                minHeight: 312,
13261
                                height: 290,
13262
                                tableName: tableName_, //'PDSEMP0001',
13263
                                param: '',
13264
                                isLookup: true,
13265
                                storename: 'storeadvance',
13266
                                pagesize: 25,
13267
                                valueField: valueField_,
13268
                                targetField: targetField_,
13269
                                hidebutton: 0, // update by hamid 20170208
13270
                                isGrid: true,
13271
                                listeners: {
13272
                                    beforeedit: function () {
13273
                                        return false;
13274
                                    },
13275
                                    itemdblclick: function () {
13276
                                        var grid = Ext.ComponentQuery.query('[name=gridlookup]')[0];
13277
                                        var selection = grid.getView().getSelectionModel().getSelection()[0];
13278
                                        var Emp_ = selection.data.EmployeeID;
13279
                                        LookupFunction = this.LookupFunction;
13280
                                        eval(LookupFunction);
13281
                                        var target = Ext.ComponentQuery.query('[name=popup_lookupEMPID]')[0].targetField;
13282
                                        Ext.ComponentQuery.query('[name=' + target + ']')[0].setValue(Emp_);
13283
                                        Ext.ComponentQuery.query('[name=popup_lookupEMPID]')[0].hide();
13284
                                    }
13285
                                },
13286
                                dockedItems: [{
13287
                                    xtype: 'pagingtoolbar',
13288
                                    store: 'storeadvance',
13289
                                    dock: 'bottom',
13290
                                    displayInfo: true
13291
                                }
13292
                                ]
13293
                            }
13294
                            ]
13295

    
13296
                        }
13297
                        ]
13298

    
13299
                    }
13300
                    ]
13301

    
13302
                }
13303
                ]
13304
            }
13305
            ]
13306
        });
13307
        me.callParent(arguments);
13308
    }
13309
});
13310

    
13311
Ext.define('MinovaUtil.MinovaES.MinovaLookupEmployee', {
13312
    extend: 'Ext.form.field.Trigger',
13313
    alias: 'widget.lookupemployee',
13314
	height: '35%',
13315
    formname: undefined,
13316
    fieldname: undefined,
13317
    allowBlank: undefined,
13318
    width: undefined,
13319
    tableName: undefined,
13320
    LookupFunction: undefined,
13321
    targetField: undefined,
13322
    vtype: 'validateMinovaXss',
13323
    fieldValue: undefined,
13324
    initComponent: function () {
13325

    
13326
        this.callParent();
13327
    },
13328
    onTriggerClick: function () {
13329
        var nameField_ = this.fieldname;
13330
        var blank = this.allowBlank;
13331
        var width_ = this.width;
13332
        var tableName_ = this.tableName;
13333
        var panelform = "form" + this.name;
13334
        //add filer by atin
13335
        var filterParam_ = this.filterParam;
13336
        // and add by atin
13337
        var _targetField = this.name;
13338
        if (this.targetField) {
13339
            _targetField = targetField
13340
        }
13341
        var fieldValue_ = this.fieldValue;
13342
        var _fieldLabel = this.fieldLabel;
13343

    
13344
        //var tableName_ = this.tableName;
13345
        var count_lookup = Ext.ComponentQuery.query('[name=popup_lookupEMPID]').length;
13346
        var lookupEMPID = Ext.ComponentQuery.query('[name=popup_lookupEMPID]')[0];
13347
        var EmployeeID = Ext.ComponentQuery.query('[name=' + _targetField + ']')[0];
13348
        var EmployeeID_ = EmployeeID.getValue();
13349
        var LookupFunction = this.LookupFunction;
13350
        var popup_lookupEMPID = Ext.ComponentQuery.query('[name=popup_lookupEMPID]').length;
13351
        if (count_lookup == 1) {
13352
            Ext.ComponentQuery.query('[name=popup_lookupEMPID]')[0].targetField = this.name;
13353
            Ext.ComponentQuery.query('[name=popup_lookupEMPID]')[0].show();
13354
        } else {
13355
            Ext.create('MinovaUtil.MinovaES.LookupEmployee', {
13356
                tableName: tableName_,
13357
                targetField: this.name,
13358
                fieldValue: fieldValue_,
13359
                LookupFunction: LookupFunction,
13360
                filterParam: filterParam_,
13361
            }).show()
13362
        }
13363
        var text = Ext.ComponentQuery.query('[name=EmployeeSearch]')[0];
13364
        text.setValue(EmployeeID_);
13365
        var store = Ext.data.StoreManager.lookup('storeQC');
13366
        if (EmployeeID_ !== "") {
13367

    
13368
            var grid = Ext.ComponentQuery.query('[name=' + _targetField + ']')[0];
13369
            if (tableName_ == 'PDSEMP0002') {
13370
                param_ = 'EmpIDExternalIDFullName[like]' + EmployeeID_
13371
            } else {
13372
                param_ = 'AppIDExternalIDFullName[like]' + EmployeeID_
13373
            }
13374
            if (filterParam_) {
13375
                param_ = param_ + ',' + filterParam_;
13376
            }
13377
            store.proxy.extraParams = {
13378
                tableName: tableName_, //'PDSEMP0002',
13379
                param: param_,
13380
                menuId: MinovaUtil.GetMenuID()
13381
            };
13382
            store.reload();
13383
        } else {
13384
            store.proxy.extraParams = {
13385
                tableName: tableName_, //'PDSEMP0002',
13386
                param: filterParam_,
13387
                menuId: MinovaUtil.GetMenuID()
13388
            };
13389
            store.reload();
13390
        }
13391

    
13392
    },
13393
    listeners: {
13394
        specialkey: function (f, e) {
13395
            if (e.getKey() == e.ENTER) {
13396
                //alert("about to submit");
13397
                var nameField_ = this.fieldname;
13398
                var blank = this.allowBlank;
13399
                var width_ = this.width;
13400
                var tableName_ = this.tableName;
13401
                var panelform = "form" + this.name;
13402
                //add filer by atin
13403
                var filterParam = this.filterParam;
13404
                // and add by atin
13405
                var _targetField = this.name;
13406
                var _fieldLabel = this.fieldLabel;
13407
                var count_lookup = Ext.ComponentQuery.query('[name=popup_lookupEMPID]').length;
13408
                var lookupEMPID = Ext.ComponentQuery.query('[name=popup_lookupEMPID]')[0];
13409
                var EmployeeID = Ext.ComponentQuery.query('[name=' + _targetField + ']')[0];
13410
                var EmployeeID_ = EmployeeID.getValue();
13411

    
13412
                var popup_lookupEMPID = Ext.ComponentQuery.query('[name=popup_lookupEMPID]').length;
13413
                if (count_lookup == 1) {
13414
                    Ext.ComponentQuery.query('[name=popup_lookupEMPID]')[0].targetField = this.name;
13415
                    Ext.ComponentQuery.query('[name=popup_lookupEMPID]')[0].show();
13416
                } else {
13417
                    Ext.create('MinovaUtil.MinovaES.LookupEmployee', {
13418
                        tableName: tableName_,
13419
                        targetField: this.name,
13420
                        fieldValue: this.fieldValue,
13421
                        LookupFunction: this.LookupFunction,
13422
                        filterParam: filterParam,
13423
                    }).show()
13424
                }
13425
                var text = Ext.ComponentQuery.query('[name=EmployeeSearch]')[0];
13426
                text.setValue(EmployeeID_);
13427

    
13428
                if (EmployeeID_ !== "") {
13429
                    var store = Ext.data.StoreManager.lookup('storeQC');
13430
                    var grid = Ext.ComponentQuery.query('[name=' + _targetField + ']')[0];
13431
                    if (tableName_ == 'PDSEMP0002') {
13432
                        param_ = 'EmpIDExternalIDFullName[like]' + EmployeeID_
13433
                    } else {
13434
                        param_ = 'AppIDExternalIDFullName[like]' + EmployeeID_
13435
                    }
13436
                    if (filterParam_) {
13437
                        param_ = param_ + ',' + filterParam_;
13438
                    }
13439
                    store.proxy.extraParams = {
13440
                        tableName: tableName_, //'PDSEMP0002',
13441
                        param: param_,
13442
                        menuId: MinovaUtil.GetMenuID()
13443
                    };
13444
                    store.reload();
13445
                }
13446
            }
13447
        }
13448
    }
13449

    
13450
});
13451
Ext.define('MinovaUtil.MinovaES.UploadFile', {
13452
    extend: 'Ext.form.field.Trigger',
13453
    alias: 'widget.uploadfile',
13454

    
13455
    //fieldLabel: undefined,
13456
    uploadName: 'uploadName',
13457
    formname: undefined,
13458
    fieldname: undefined,
13459
    allowBlank: undefined,
13460
    width: undefined,
13461
    tableName: undefined,
13462
    initComponent: function () {
13463

    
13464
        this.callParent();
13465
    },
13466
    onTriggerClick: function () {
13467
        var nameField_ = this.fieldname;
13468
        var blank = this.allowBlank;
13469
        var width_ = this.width;
13470
        var tableName_ = this.tableName;
13471
        var panelform = "form" + this.name;
13472
        var val_ = this.value;
13473
        var _targetField = this.name;
13474
        var _fieldLabel = this.fieldLabel;
13475

    
13476
        //var tableName_ = this.tableName;
13477
        var count_lookup = Ext.ComponentQuery.query('[name=FormFileUpload]').length;
13478
        var lookupEMPID = Ext.ComponentQuery.query('[name=FormFileUpload]')[0];
13479
        var EmployeeID = Ext.ComponentQuery.query('[name=' + _targetField + ']')[0];
13480
        var EmployeeID_ = EmployeeID.getValue();
13481

    
13482
        var FormFileUpload = Ext.ComponentQuery.query('[name=FormFileUpload]').length;
13483
        Ext.create('MinovaES.view.uploadfile.fileupload', {
13484
            tableName: tableName_,
13485
            targetField: this.name,
13486
            valueFile: val_,
13487
            titleLookup: _fieldLabel,
13488
        }).show()
13489

    
13490
    }
13491

    
13492
});
13493

    
13494
//atien
13495
Ext.define('MinovaES.view.uploadfile.fileupload', {
13496
    extend: 'Ext.window.Window',
13497
    alias: 'widget.fileupload',
13498
    requires: [
13499

    
13500
    ],
13501
    //height: '67%',
13502
    width: '35%',
13503
    minWidth: '50%',
13504
    maxWidth: '100%',
13505
    bodyPadding: 0,
13506
    formname: undefined,
13507
    fieldname: undefined,
13508
    modal: true,
13509
    title: 'Upload ',
13510
    name: 'FormLookup',
13511
    test: undefined,
13512
    targetField: undefined,
13513
    tableName: undefined,
13514
    listeners: {
13515
        afterrender: function (f) {
13516
            f.setTitle('Upload ' + f.titleLookup);
13517
            var id_ = Ext.ComponentQuery.query('minovanumberfield[name=FileID]')[0];
13518
            if (id_) {
13519
                var valID = id_.getValue();
13520
                Ext.ComponentQuery.query('textfield[name=FileID_]')[0].setValue(valID);
13521
            }
13522
        },
13523
    },
13524
    initComponent: function () {
13525
        var me = this;
13526
        var targetField_ = me.targetField;
13527
        var titleLookup_ = me.titleLookup;
13528
        var maxFileSize = me.maxFileSize;
13529
        var fileName = me.valueFile;
13530
        Ext.applyIf(me, {
13531
            items: [{
13532
                xtype: 'form',
13533
                name: 'FormFileUpload',
13534
                valueFile: fileName,
13535
                buttons: [{
13536
                    xtype: 'button',
13537
                    iconCls: 'fa-upload',
13538
                    style: 'font-family: FontAwesome',
13539
                    text: 'Upload',
13540
                    action: 'Upload',
13541
                    name: 'Upload',
13542
                    handler: function () {
13543
                        maxFileSize = Ext.ComponentQuery.query('uploadfile[name=' + targetField_ + ']')[0].maxFileSize;
13544
                        Ext.ComponentQuery.query('[name=FileMax]')[0].setValue(maxFileSize);
13545
                        var form = Ext.ComponentQuery.query('form[name=FormFileUpload]')[0].getForm();
13546
                        pnl = Ext.ComponentQuery.query('[name=FormLookup]')[0]; // by hamid 20170206
13547
                        if (form.isValid()) {
13548
                            form.submit({
13549
                                url: '/Devt/UploadFile',
13550
                                waitMsg: 'Uploading your file...',
13551
                                success: function (fp, o) {
13552
                                    var result = o.result;
13553
                                    Ext.ComponentQuery.query('uploadfile[name=' + targetField_ + ']')[0].setValue(result.FileName);
13554
                                    Ext.ComponentQuery.query('[name=FormFileUpload]')[0].valueFile = result.FileName;
13555
                                    Ext.ComponentQuery.query('[name=download]')[0].fileName = result.FileName;
13556
                                    var fileID = Ext.ComponentQuery.query('minovanumberfield[name=FileID]')[0]
13557
                                    if (fileID) {
13558
                                        fileID.setValue(result.ID);
13559
                                    }
13560

    
13561
                                    if (result.msg === "") {
13562
                                        if (me.onSuccess !== undefined)
13563
                                            me.onSuccess(result.FileName, result.content_type);
13564
                                        pnl.destroy(); // by hamid 20170206
13565
                                    } else
13566
                                        alert(result.msg);
13567
										
13568
									//by Agung 20200428
13569
									Ext.ComponentQuery.query('[name=FORMPHRUPLOADFILE]')[0].getForm().findField('FileID').setValue(result.ID);
13570
									Ext.ComponentQuery.query('[name=FORMPHRUPLOADFILE]')[0].getForm().findField('FileName').setValue(result.FileName);
13571
                                }
13572
                            });
13573
                        }
13574
                    }
13575
                }, {
13576
                    xtype: 'button',
13577
                    text: 'Clear',
13578
                    width: 60,
13579
                    handler: function () {
13580
                        //Ext.ComponentQuery.query('[name=' + nameField_ + ']')[0].setValue('');
13581
                        Ext.ComponentQuery.query('[name=' + targetField_ + ']')[0].setValue(''); // by hamid 20170206
13582
                    }
13583
                }, {
13584
                    xtype: 'button',
13585
                    text: 'Download',
13586
                    name: 'download',
13587
                    width: 60,
13588
                    fileName: fileName,
13589
                    handler: function (f) {
13590
                        var url = '/Devt/GetFileData?FileName=' + f.fileName + '&download=true';
13591
                        window.open(url, '_blank');
13592
                    }
13593
                    //href: '/Devt/GetFileData?FileName=' + me.valueFile + '&download=true',
13594

    
13595
                }
13596
                ],
13597
                items: [{
13598
                    xtype: 'filefield',
13599
                    name: 'File',
13600
                    fieldLabel: 'Select File',
13601
                    //allowBlank: false,
13602
                    //width: 270,
13603
                    //labelWidth: 85,
13604
                }, {
13605
                    xtype: 'textfield',
13606
                    name: 'FileID_',
13607
                    hidden: true,
13608
                }, {
13609
                    xtype: 'textfield',
13610
                    name: 'FileMax',
13611
                    hidden: true,
13612
                }
13613
                ]
13614
            }
13615
            ]
13616
        });
13617
        me.callParent(arguments);
13618
    }
13619
});
13620
//atien
13621

    
13622

    
13623
//update by hamid 12012017
13624
Ext.define('MinovaES.view.uploadfile.fileupload1', {
13625
    extend: 'Ext.window.Window',
13626
    alias: 'widget.fileupload1',
13627
    requires: [
13628

    
13629
    ],
13630
    height: '67%',
13631
    width: '21%',
13632
    minWidth: '50%',
13633
    maxWidth: '100%',
13634
    bodyPadding: 0,
13635
    formname: undefined,
13636
    fieldname: undefined,
13637
    //modal: true,
13638
    title: 'Lookup - Photo',
13639
    name: 'FormLookup',
13640
    test: undefined,
13641
    targetField: undefined,
13642
    tableName: undefined,
13643
    initComponent: function () {
13644
        var me = this;
13645
        var targetField_ = me.targetField;
13646
        var nameField_ = this.fieldname;
13647
        var form = me.test;
13648
        var tableName_ = me.tableName;
13649
        //var img_ = Ext.ComponentQuery.query('[name=Photo]')[0].getValue()
13650
        var img_ = Ext.ComponentQuery.query('[name=' + nameField_ + ']')[0];
13651
        Ext.applyIf(me, {
13652
            // items: [{
13653
            //xtype : 'panel',
13654
            items: [{
13655
                xtype: 'tabpanel',
13656
                //name: 'mainTab',
13657
                items: [{
13658
                    xtype: 'form',
13659
                    title: 'Upload File',
13660
                    height: '70%',
13661
                    name: 'FormFileUpload',
13662
                    buttons: [{
13663
                        xtype: 'button',
13664
                        iconCls: 'fa-upload',
13665
                        style: 'font-family: FontAwesome',
13666
                        text: 'Upload',
13667
                        action: 'Upload',
13668
                        name: 'Upload',
13669
                        handler: function () {
13670
                            //var Tab = Ext.ComponentQuery.query('[name=mainTab]')[0].getActiveTab();
13671
                            var form = Ext.ComponentQuery.query('form[name=FormFileUpload]')[0].getForm();
13672
                            pnl = Ext.ComponentQuery.query('[name=FormLookup]')[0];
13673
                            if (form.isValid()) {
13674
                                form.submit({
13675
                                    url: '/Devt/UploadFile',
13676
                                    waitMsg: 'Uploading your file...',
13677
                                    success: function (fp, o) {
13678
                                        var result = o.result;
13679
                                        Ext.ComponentQuery.query('[name=' + targetField_ + ']')[0].setValue(result.FileName)
13680
                                        //Ext.ComponentQuery.query('[name=Photo]')[0].setValue(result.FileName)
13681
                                        if (result.msg === "") {
13682
                                            //alert('success');
13683
                                            if (me.onSuccess !== undefined)
13684
                                                me.onSuccess(result.FileName, result.content_type);
13685
                                            pnl.destroy();
13686
                                        } else
13687
                                            alert(result.msg);
13688
                                    }
13689
                                });
13690
                            }
13691
                        }
13692
                    }, {
13693
                        xtype: 'button',
13694
                        text: 'Clear',
13695
                        width: 60,
13696
                        handler: function () {
13697
                            Ext.ComponentQuery.query('[name=' + nameField_ + ']')[0].setValue('');
13698
                            //Ext.ComponentQuery.query('[name=Photo]')[0].setValue('');
13699

    
13700
                        }
13701
                    }
13702
                    ],
13703
                    items: [{
13704
                        xtype: 'fieldset',
13705
                        layout: 'hbox',
13706
                        width: '100%',
13707
                        bodyPadding: 10,
13708
                        border: 0,
13709
                        padding: 0,
13710
                        items: [{
13711
                            xtype: 'filefield',
13712
                            name: 'File',
13713
                            fieldLabel: 'Select File',
13714
                            //allowBlank: false,
13715
                            width: 270,
13716
                            labelWidth: 85,
13717
                        }
13718
                        ]
13719
                    }
13720
                    ]
13721
                    //items: [{
13722
                    //    xtype: 'form',
13723
                    //    name: 'Photo',
13724
                    //    width: '100%',
13725
                    //    height: 'auto',
13726
                    //    dockedItems: [{
13727
                    //        xtype: 'toolbar',
13728
                    //        dock: 'top',
13729
                    //        layout: 'vbox',
13730
                    //        bodyPadding: 10,
13731
                    //        border: 0,
13732
                    //        items: [{
13733
                    //            xtype: 'fieldset',
13734
                    //            layout: 'hbox',
13735
                    //            width: '100%',
13736
                    //            border: 0,
13737
                    //            padding: 0,
13738
                    //            items: [{
13739
                    //                xtype: 'filefield',
13740
                    //                name: 'SelectFile',
13741
                    //                fieldLabel: 'Select File',
13742
                    //                width: 270,
13743
                    //                labelWidth: 85,
13744
                    //                enableKeyEvents: true,
13745
                    //                buttonText: 'Browse',
13746
                    //            }]
13747

    
13748
                    //        }
13749
                    //        ]
13750
                    //    }
13751
                    //    ]
13752
                    //}]
13753
                }, {
13754
                    title: 'View Image',
13755
                    //height: 400,
13756
                    //autoScroll: true,
13757
                    items: [{
13758
                        xtype: 'form',
13759
                        name: 'ViewImage',
13760
                        //margin: '5 5 5 5',
13761
                        items: [{
13762
                            xtype: 'form',
13763
                            buttons: [{
13764
                                text: 'Download',
13765
                                handler: function () {},
13766
                                href: '/Devt/GetFileData?FileName=' + img_ + '&download=true'
13767

    
13768
                            }
13769
                            ],
13770
                            items: [{
13771
                                xtype: 'image',
13772
                                //id: 'imageuser',
13773
                                src: '/Devt/GetFileData?FileName=' + img_ + '&download=false'
13774
                            },
13775
                            ]
13776
                        }
13777
                        ]
13778

    
13779
                    }
13780
                    ]
13781

    
13782
                }
13783
                ]
13784

    
13785
            }
13786
            ]
13787

    
13788
        });
13789
        me.callParent(arguments);
13790
    }
13791
});
13792

    
13793
Ext.define('MinovaUtil.MinovaES.Column.MinovaPictureColumn', {
13794
    extend: 'Ext.grid.column.Column',
13795
    alias: ['widget.minovapicturecolumn'],
13796
    alternateClassName: 'Ext.grid.MinovaPictureColumn',
13797
    //undefinedText: '&#160;',
13798
    defaultRenderer: function (value) {
13799
        return '<img alt="" class="icon-imagecolumn" src = "/Devt/GetFileData?FileName=' + value + '&download=false"  id="">'
13800
    }
13801
});
13802

    
13803
Ext.define('MinovaUtil.MinovaES.MinovaFixValue', {
13804
    extend: 'Ext.form.field.ComboBox',
13805
    alias: ['widget.MinovaFixValue', 'widget.minovafixvalue'],
13806
    fixedValue: undefined,
13807
    anchor: '50%',
13808
    queryMode: 'local',
13809
    forceSelection: true, // cek data
13810
    getValue: function () {
13811
        var value = this.value;
13812

    
13813
        return value;
13814
    },
13815
    getSubmitValue: function () {
13816
        var value = this.value;
13817

    
13818
        return value;
13819
    },
13820
    initComponent: function () {
13821
        var me = this;
13822
        var storeData = [];
13823
        //var str= "y=yes|| n=no";
13824
        var str = me.fixedValue;
13825
        var hasil = str.split('||');
13826
        hasil.forEach(function (h) {
13827
            store_ = h.split('=')
13828
            storeData.push({
13829
                code: store_[0],
13830
                desc: store_[1],
13831

    
13832
            });
13833
        });
13834
        Ext.applyIf(me, {
13835

    
13836
            store: Ext.create('Ext.data.Store', {
13837
                storeId: 'store' + name,
13838
                autoLoad: true,
13839
                data: storeData
13840

    
13841
            }),
13842
        });
13843
        me.callParent(arguments);
13844
    }
13845
});
13846

    
13847
Ext.define('MinovaUtil.MinovaES.MinovaDecimal', {
13848
    extend: 'Ext.form.field.Text',
13849
    alias: ['widget.MinovaDecimal', 'widget.minovadecimal'],
13850
    fixedValue: undefined,
13851
    anchor: '50%',
13852
    getValue: function () {
13853
        var value = this.value;
13854

    
13855
        return value.replace(',', '.');
13856
    },
13857
    getSubmitValue: function () {
13858
        var value = this.value;
13859
        return value.replace(',', '.');
13860
    },
13861
    initComponent: function () {
13862
        var me = this;
13863
        Ext.applyIf(me, {});
13864
        me.callParent(arguments);
13865
    }
13866
});
13867

    
13868
Ext.define('MinovaUtil.com.xtype.MinovaWorflowEditor', {
13869
    extend: 'Ext.panel.Panel',
13870
    alias: ['widget.minovawfeditor', 'widget.minovafloweditor'],
13871
    title: undefined,
13872
    initComponent: function () {
13873
        // this.layout = 'fit';
13874
        this.readOnly = this.readOnly ? this.readOnly : false;
13875
        this.autoScroll = true;
13876
        this.height = 480;
13877
        this.title = this.title ? this.title : 'Workflow editor';
13878
        this.html = '<div id="minovaGraphContainer" title="' + this.title
13879
			 + '" style="background:url(\'' + mxBasePath
13880
			 + '/editors/images/grid.gif\')"></div>';
13881
        this.tbar = [{
13882
            xtype: 'button',
13883
            hidden: true,
13884
            text: 'add Task',
13885
            handler: this.addTask
13886

    
13887
        }, {
13888
            xtype: 'button',
13889
            text: 'Remove',
13890
            hidden: true,
13891
            handler: this.removeCells
13892
        },
13893
			'->', {
13894
			    xtype: 'cycle',
13895
			    text: 'layout',
13896
			    menu: {
13897
			        // id : 'view-type-menu',
13898
			        items: [{
13899
			            text: 'mxCircleLayout'
13900
			        }, {
13901
			            text: 'mxCompactTreeLayout'
13902
			        }, {
13903
			            text: 'mxCompositeLayout'
13904
			        }, {
13905
			            text: 'mxEdgeLabelLayout'
13906
			        }, {
13907
			            text: 'mxFastOrganicLayout'
13908
			        }, {
13909
			            text: 'mxGraphLayout'
13910
			        }, {
13911
			            text: 'mxHierarchicalLayout'
13912
			        }
13913
						// , {
13914
						// text : 'mxParallelEdgeLayout'
13915
						// }
13916
						// , {
13917
						// text : 'mxPartitionLayout'
13918
						// },
13919
						// {
13920
						// text : 'mxStackLayout'
13921
						// }
13922
			        ]
13923
			    },
13924
			    changeHandler: function (cycleBtn, activeItem) {
13925
			        // Ext.Msg.alert('Change View', activeItem.text);
13926
			        try {
13927
			            switch (activeItem.text) {
13928
			                case 'mxCircleLayout':
13929
			                    var layout = new mxCircleLayout(graph);
13930
			                    layout.execute(graph.getDefaultParent());
13931
			                    break;
13932
			                case 'mxCompactTreeLayout':
13933
			                    var layout = new mxCompactTreeLayout(graph,
13934
                                        false);
13935
			                    layout.execute(graph.getDefaultParent());
13936
			                    break;
13937
			                case 'mxCompositeLayout':
13938
			                    var first = new mxFastOrganicLayout(graph);
13939
			                    var second = new mxParallelEdgeLayout(graph);
13940
			                    var layout = new mxCompositeLayout(graph, [
13941
                                            first, second], first);
13942
			                    layout.execute(graph.getDefaultParent());
13943
			                    break;
13944
			                case 'mxEdgeLabelLayout':
13945
			                    var layout = new mxEdgeLabelLayout(graph);
13946
			                    layout.execute(graph.getDefaultParent());
13947
			                    break;
13948
			                case 'mxFastOrganicLayout':
13949
			                    var layout = new mxCircleLayout(graph);
13950
			                    layout.execute(graph.getDefaultParent());
13951
			                    break;
13952
			                case 'mxGraphLayout':
13953
			                    var layout = new mxFastOrganicLayout(graph);
13954
			                    layout.execute(graph.getDefaultParent());
13955
			                    break;
13956
			                case 'mxParallelEdgeLayout':
13957
			                    var layout = new mxParallelEdgeLayout(graph);
13958
			                    layout.execute(graph.getDefaultParent());
13959
			                    break;
13960
			                case 'mxPartitionLayout':
13961
			                    var layout = new mxPartitionLayout(graph,
13962
                                        true, 10, 20);
13963
			                    layout.execute(graph.getDefaultParent());
13964
			                    break;
13965
			                case 'mxStackLayout':
13966
			                    var layout = new mxStackLayout(graph, false);
13967
			                    layout.execute(graph.getDefaultParent());
13968
			                    break;
13969
			                case 'mxHierarchicalLayout':
13970
			                    var layout = new mxHierarchicalLayout(graph);
13971
			                    layout.parallelEdgeSpacing = 100;
13972
			                    layout.moveParent = true;
13973
			                    layout.parentBorder = 100;
13974
			                    layout.intraCellSpacing = 100;
13975
			                    layout.interRankCellSpacing = 100;
13976
			                    layout.interHierarchySpacing = 0;
13977
			                    layout.orientation = mxConstants.DIRECTION_NORTH;
13978
			                    //layout.traverseAncestors = false;
13979
			                    layout.execute(parent);
13980
			                    break;
13981

    
13982
			            }
13983
			        } catch (e) {}
13984
			    }
13985
			}, {
13986
			    xtype: 'tbseparator'
13987
			}, {
13988
			    text: 'In',
13989
			    name: 'zoomin',
13990
			    handler: function () {
13991
			        graph.zoomIn();
13992
			        graph.fit();
13993
			    }
13994
			}, {
13995
			    text: 'Out',
13996
			    name: 'zoomout',
13997
			    handler: function () {
13998
			        graph.zoomOut();
13999
			        graph.fit();
14000
			    }
14001
			}
14002
			// , {
14003
			// text : 'Fit',
14004
			// name : 'zoomfit',
14005
			// handler : function() {
14006
			// graph.fit();
14007
			// }
14008
			// }
14009
		, {
14010
		    xtype: 'tbseparator'
14011
		}, {
14012
		    xtype: 'button',
14013
		    text: 'print',
14014
		    name: 'print',
14015
		    handler: this.printPreview
14016
		}
14017
        ]
14018

    
14019
        this.autoScroll = true;
14020
        this.listeners = {
14021
            afterrender: this.onAfterRender,
14022
            resize: this.onResize
14023
        }
14024

    
14025
        this.callParent(arguments);
14026
    },
14027
    printPreview: function () {
14028
        var preview = new mxPrintPreview(graph);
14029
        preview.print();
14030
    },
14031
    onAfterRender: function (_this) {
14032
        this.main(document.getElementById('minovaGraphContainer'));
14033
    },
14034
    removeCells: function () {
14035
        graph.removeCells();
14036
    },
14037
    onResize: function () {
14038
        try {
14039
            graph.sizeDidChange();
14040
        } catch (e) {}
14041
    },
14042
    addTask: function () {
14043
        graph.insertVertex(graph.getDefaultParent(), null, 'Task-' + Ext.id(),
14044
			0, 0, 80, 30);
14045
    },
14046
    main: function (container) {
14047
        // Checks if the browser is supported
14048
        if (!mxClient.isBrowserSupported()) {
14049
            // Displays an error message if the browser is not supported.
14050
            // mxUtils.error('Browser is not supported!', 200, false);
14051
            alert('Browser is not supported!');
14052
        } else {
14053
            // // Creates the graph inside the given container
14054
            // graph = new mxGraph(container);
14055
            // var keyHandler = new mxKeyHandler(graph);
14056
            // // keyHandler.bindKey(46, function(evt) {
14057
            // // if (graph.isEnabled()) {
14058
            // // graph.removeCells();
14059
            // // }
14060
            // // });
14061
            // wfEditor = new mxEditor();
14062
            //
14063
            // // Enables rubberband selection
14064
            //
14065
            // new mxRubberband(graph);
14066
            // graph.setPanning(true);
14067
            // graph.setTooltips(true);
14068
            //
14069
            // // graph.setConnectable(true);
14070
            // // graph.setDropEnabled(true);
14071
            // // graph.connectionHandler.setCreateTarget(true);
14072
            //
14073
            // // Gets the default parent for inserting new cells. This
14074
            // // is normally the first child of the root (ie. layer 0).
14075
            // var parent = graph.getDefaultParent();
14076

    
14077
            // Enables crisp rendering in SVG
14078
            // mxShape.prototype.crisp = true;
14079

    
14080
            // Enables guides
14081
            // mxGraphHandler.prototype.guidesEnabled = true;
14082

    
14083
            // Alt disables guides
14084
            // mxGuide.prototype.isEnabledForEvent = function(evt) {
14085
            // return !mxEvent.isAltDown(evt);
14086
            // };
14087

    
14088
            // Enables snapping waypoints to terminals
14089
            // mxEdgeHandler.prototype.snapToTerminals = true;
14090

    
14091
            // Enables orthogonal connect preview in IE
14092
            // mxConnectionHandler.prototype.movePreviewAway = true;
14093

    
14094
            // Creates the graph inside the given container
14095
            graph = new mxGraph(container);
14096
            // graph.disconnectOnMove = false;
14097
            // graph.foldingEnabled = false;
14098
            // graph.cellsResizable = false;
14099
            // graph.extendParents = false;
14100
            // graph.setConnectable(true);
14101
            graph.setAllowDanglingEdges(false);
14102

    
14103
            // Implements perimeter-less connection points as fixed points
14104
            // (computed before the edge style).
14105
            // graph.view.updateFixedTerminalPoint = function(edge, terminal,
14106
            // source, constraint) {
14107
            // mxGraphView.prototype.updateFixedTerminalPoint.apply(this,
14108
            // arguments);
14109
            //
14110
            // var pts = edge.absolutePoints;
14111
            // var pt = pts[(source) ? 0 : pts.length - 1];
14112
            //
14113
            // if (terminal != null && pt == null
14114
            // && this.getPerimeterFunction(terminal) == null) {
14115
            // edge.setAbsoluteTerminalPoint(new mxPoint(this
14116
            // .getRoutingCenterX(terminal), this
14117
            // .getRoutingCenterY(terminal)),
14118
            // source)
14119
            // }
14120
            // };
14121

    
14122
            // Changes the default edge style
14123
            graph.getStylesheet().getDefaultEdgeStyle()['edgeStyle'] = 'orthogonalEdgeStyle';
14124
            // delete graph.getStylesheet().getDefaultEdgeStyle()['endArrow'];
14125

    
14126
            // Implements the connect preview
14127
            graph.connectionHandler.createEdgeState = function (me) {
14128
                var edge = graph.createEdge(null, null, null, null, null);
14129

    
14130
                return new mxCellState(this.graph.view, edge, this.graph
14131
					.getCellStyle(edge));
14132
            };
14133

    
14134
            // Uncomment the following if you want the container
14135
            // to fit the size of the graph
14136
            // graph.setResizeContainer(true);
14137

    
14138
            // Enables rubberband selection
14139
            new mxRubberband(graph);
14140

    
14141
            // Disables basic selection and cell handling
14142
            graph.setEnabled(false);
14143

    
14144
            // Gets the default parent for inserting new cells. This
14145
            // is normally the first child of the root (ie. layer 0).
14146
            var parent = graph.getDefaultParent();
14147

    
14148
            // Enables HTML labels as wrapping is only available for those
14149
            graph.htmlLabels = true;
14150

    
14151
            // Disables in-place editing for edges
14152
            // graph.isCellEditable = function(cell) {
14153
            // return !this.model.isEdge(cell);
14154
            // };
14155

    
14156
            // Changes the default vertex style in-place
14157
            var style = graph.getStylesheet().getDefaultVertexStyle();
14158
            style[mxConstants.STYLE_PERIMETER] = mxPerimeter.RectanglePerimeter;
14159
            style[mxConstants.STYLE_GRADIENTCOLOR] = 'white';
14160
            style[mxConstants.STYLE_PERIMETER_SPACING] = 1; // 6;
14161
            style[mxConstants.STYLE_ROUNDED] = true;
14162
            style[mxConstants.STYLE_SHADOW] = true;
14163

    
14164
            style = graph.getStylesheet().getDefaultEdgeStyle();
14165
            style[mxConstants.STYLE_ROUNDED] = true;
14166
            style[mxConstants.STYLE_EDGE] = mxEdgeStyle.SegmentConnector;
14167

    
14168
            var style2 = new Object();
14169
            style2[mxConstants.STYLE_SHAPE] = mxConstants.SHAPE_RHOMBUS;
14170
            style2[mxConstants.STYLE_PERIMETER] = mxPerimeter.RhombusPerimeter;
14171
            style2[mxConstants.STYLE_GRADIENTCOLOR] = 'white';
14172
            style2[mxConstants.STYLE_PERIMETER_SPACING] = 1;
14173
            style2[mxConstants.STYLE_ROUNDED] = true;
14174
            style2[mxConstants.STYLE_SHADOW] = true;
14175
            style2[mxConstants.STYLE_STROKECOLOR] = '#B3BFD7';
14176
            style2[mxConstants.STYLE_FILLCOLOR] = '#C4DAFF';
14177
            style2[mxConstants.STYLE_ALIGN] = 'center';
14178
            style2[mxConstants.STYLE_VERTICALALIGN] = 'middle';
14179
            graph.getStylesheet().putCellStyle('RHOMBUS', style2);
14180

    
14181
            style2 = new Object();
14182
            style2[mxConstants.STYLE_SHAPE] = mxConstants.SHAPE_ELLIPSE;
14183
            style2[mxConstants.STYLE_PERIMETER] = mxPerimeter.EllipsePerimeter;
14184
            style2[mxConstants.STYLE_GRADIENTCOLOR] = 'white';
14185
            style2[mxConstants.STYLE_PERIMETER_SPACING] = 1;
14186
            style2[mxConstants.STYLE_ROUNDED] = true;
14187
            style2[mxConstants.STYLE_SHADOW] = true;
14188
            style2[mxConstants.STYLE_STROKECOLOR] = '#B3BFD7';
14189
            style2[mxConstants.STYLE_FILLCOLOR] = '#C4DAFF';
14190
            style2[mxConstants.STYLE_ALIGN] = 'center';
14191
            style2[mxConstants.STYLE_VERTICALALIGN] = 'middle';
14192
            graph.getStylesheet().putCellStyle('ELLIPSE', style2);
14193

    
14194
            style2 = new Object();
14195
            style2[mxConstants.STYLE_SHAPE] = 'label';
14196
            style2[mxConstants.STYLE_VERTICAL_ALIGN] = 'bottom';
14197
            style2[mxConstants.STYLE_INDICATOR_SHAPE] = 'ellipse';
14198
            style2[mxConstants.STYLE_INDICATOR_WIDTH] = 34;
14199
            style2[mxConstants.STYLE_INDICATOR_HEIGHT] = 34;
14200
            style2[mxConstants.STYLE_IMAGE_VERTICAL_ALIGN] = 'top'; // indicator v-alignment
14201
            style2[mxConstants.STYLE_IMAGE_ALIGN] = 'center';
14202
            graph.getStylesheet().putCellStyle('LABEL', style2);
14203

    
14204
            style2 = new Object();
14205
            style2[mxConstants.STYLE_SHAPE] = mxConstants.SHAPE_RECTANGLE;
14206
            style2[mxConstants.STYLE_PERIMETER] = mxPerimeter.RectanglePerimeter;
14207
            style2[mxConstants.STYLE_GRADIENTCOLOR] = 'white';
14208
            style2[mxConstants.STYLE_PERIMETER_SPACING] = 1;
14209
            style2[mxConstants.STYLE_ROUNDED] = false;
14210
            style2[mxConstants.STYLE_SHADOW] = true;
14211
            style2[mxConstants.STYLE_STROKECOLOR] = '#B3BFD7';
14212
            style2[mxConstants.STYLE_FILLCOLOR] = '#C4DAFF';
14213
            graph.getStylesheet().putCellStyle('RECTANGLE', style2);
14214
            // Adds cells to the model in a single step
14215
            graph.getModel().beginUpdate();
14216
            try {
14217
                // var v1 = graph.insertVertex(parent, null, '1', 20, 0, 150,
14218
                // 80);
14219
                // var v2 = graph.insertVertex(parent, null, '2', 20, 50, 150,
14220
                // 80);
14221
                // var v3 = graph
14222
                // .insertVertex(parent, null, '3', 20, 100, 150, 80);
14223
                // var v4 = graph
14224
                // .insertVertex(parent, null, '4', 120, 50, 150, 80);
14225
                // var v5 = graph.insertVertex(parent, null, '5', 120, 100, 150,
14226
                // 80);
14227
                //
14228
                // var e1 = graph.insertEdge(parent, null, '', v1, v2);
14229
                // var e2 = graph.insertEdge(parent, null, '', v2, v3);
14230
                // var e3 = graph.insertEdge(parent, null, '', v2, v4);
14231
                // var e4 = graph.insertEdge(parent, null, '', v4, v5);
14232
                // var e5 = graph.insertEdge(parent, null, '', v3, v5);
14233
            }
14234
            finally {
14235
                // Updates the display
14236
                graph.getModel().endUpdate();
14237
            }
14238

    
14239
        }
14240
    }
14241
});
14242

    
14243
Ext.define('MinovaUtil.MinovaES.MinovaMonthPicker', {
14244
    extend: 'Ext.form.field.Text',
14245
    alias: ['widget.minovamonthpicker', 'widget.minovamonthpicker'],
14246
    tableName: undefined,
14247
    param: undefined,
14248
    formtarget_: this.formtarget,
14249
    Sequence: this.Sequence,
14250
    anchor: '50%',
14251
    pagesize: undefined,
14252
    triggerCls: 'x-form-date-trigger',
14253
    getValue: function () {
14254
        var Sequence = this.Sequence;
14255
        var me = this;
14256
        var _e = Ext.ComponentQuery.query('[name=' + Sequence + 'monthselect]')[0];
14257
        var hasil = "";
14258
        if (_e != undefined) {
14259
            if (_e.value[0] >= 0) {
14260
                if (_e.value[0].toString() != '') {
14261
                    var _m = (_e.value[0] + 1).toString();
14262
                    if (_m.length == 1) {
14263
                        _m = '0' + _m;
14264
                    }
14265
                    hasil = _e.value[1].toString() + _m;
14266
                }
14267
            }
14268
        }
14269
        if (hasil == "") {
14270
            me.value = null;
14271
            me.submitValue = null;
14272
        } else {
14273
            me.submitValue = hasil;
14274
        }
14275
        return hasil;
14276
    },
14277
    clearValue: function () {
14278
        var Sequence = this.Sequence;
14279
        var _e = Ext.ComponentQuery.query('[name=' + Sequence + 'monthselect]')[0];
14280
        _e.value[0] = '';
14281
        _e.value[1] = '';
14282
        return this.setValue('');
14283
    },
14284
    getRawValue: function () {
14285
        var Sequence = this.Sequence;
14286
        var _e = Ext.ComponentQuery.query('[name=' + Sequence + 'monthselect]')[0];
14287
        var hasil = null;
14288
        if (_e != undefined) {
14289
            var _m = (_e.value[0] + 1).toString();
14290
            if (_m.length == 1) {
14291
                _m = '0' + _m;
14292
            }
14293
            hasil = _e.value[1].toString() + _m;
14294
        }
14295
        return hasil;
14296
    },
14297
    initComponent: function () {
14298
        var target = this.formtarget;
14299
        this.callParent();
14300
    },
14301
    onTriggerClick: function () {
14302
        var Sequence = this.Sequence;
14303
        var count_lookup = Ext.ComponentQuery.query('[name=' + Sequence + 'monthLookup]').length;
14304
        if (count_lookup == 1) {
14305
            Ext.ComponentQuery.query('[name=' + Sequence + 'monthLookup]')[0].show();
14306
        } else {
14307
            var target_ = this.formtarget;
14308
            var fieldtarget = this.name;
14309
            Ext.create('Ext.window.Window', {
14310
                title: 'Select Period',
14311
                name: Sequence + 'monthLookup',
14312
                layout: 'fit',
14313
                bodyPadding: 0,
14314
                border: false,
14315
                items: [{
14316
                    xtype: 'monthpicker',
14317
                    name: Sequence + 'monthselect',
14318
                    listeners: {
14319
                        afterrender: function () {
14320
                            var _e = Ext.ComponentQuery.query('[name=' + Sequence + 'monthselect]')[0];
14321

    
14322
                            _e.setValue(new Date());
14323
                        }
14324
                    },
14325
                    onOkClick: function () {
14326
                        var _e = Ext.ComponentQuery.query('[name=' + Sequence + 'monthselect]')[0];
14327
                        if (_e.value[0] == null || _e.value[1] == null) {
14328
                            alert('Pilih Tanggal!');
14329
                            return;
14330
                        }
14331

    
14332
                        var _m = (_e.value[0] + 1).toString();
14333
                        if (_m.length == 1) {
14334
                            _m = '0' + _m;
14335
                        }
14336
                        var _period = _m + ' - ' + _e.value[1].toString();
14337

    
14338
                        var _f = Ext.ComponentQuery.query('[name=' + fieldtarget + ']')[0];
14339
                        _f.setValue(_period);
14340

    
14341
                        Ext.ComponentQuery.query('[name=' + Sequence + 'monthLookup]')[0].hide();
14342
                    },
14343
                    onCancelClick: function () {
14344
                        Ext.ComponentQuery.query('[name=' + Sequence + 'monthLookup]')[0].hide();
14345
                    }
14346
                }
14347
                ]
14348
            }).show();
14349
        }
14350
    }
14351
});
14352

    
14353
Ext.define('MinovaUtil.MinovaES.Column.MinovaTimeColumn', {
14354
    extend: 'Ext.grid.column.Column',
14355
    alias: ['widget.minovatimecolumn'],
14356
    alternateClassName: 'Ext.grid.MinovaTimeColumn',
14357
    undefinedText: '&#160;',
14358
    defaultRenderer: function (value) {
14359
        if (value === "") {
14360
            return "";
14361
        }
14362
        return hasil;
14363
    }
14364
});
14365

    
14366
Ext.define('MinovaUtil.MinovaES.Column.MinovaCurrencyColumn', {
14367
    extend: 'Ext.grid.column.Column',
14368
    alias: ['widget.minovacurrancycolumn'],
14369
    undefinedText: '&#160;',
14370
    defaultRenderer: function (value) {
14371
        if (value === "" || value === undefined || value === null) {
14372
            return this.undefinedText;
14373
        }
14374

    
14375
        Ext.util.Format.thousandSeparator = ",";
14376
        Ext.util.Format.decimalSeparator = ".";
14377
        value = value.toString().replace(',', '.');
14378
        return Ext.util.Format.number(value, '0,000.00');
14379
    }
14380
});
14381

    
14382
Ext.define('MinovaUtil.MinovaES.Field.MinovaCurrencyField', {
14383
    extend: 'Ext.form.field.Text',
14384
    alias: ['widget.MinovaCurrencyField', 'widget.minovacurrencyfield'],
14385
    undefinedText: '&#160;',
14386
    defaultRenderer: function (value) {
14387
        if (value === "" || value === undefined || value === null) {
14388
            return this.undefinedText;
14389
        }
14390

    
14391
        Ext.util.Format.thousandSeparator = ",";
14392
        Ext.util.Format.decimalSeparator = ".";
14393
        value = value.toString().replace(',', '.');
14394
        return Ext.util.Format.number(value, '0000.00');
14395
    }
14396
});
14397

    
14398
Ext.define('MinovaUtil.MinovaES.MinovaGridMD', {
14399
    extend: 'Ext.grid.Panel',
14400
    requires: ['Ext.grid.RowNumberer'],
14401
    alias: 'widget.minovagridmd',
14402
    //alias: ['widget.minovagrid1', 'widget.minovagrid'],
14403
    //alias: ['widget.minovagrid1', 'widget.minovagrid'],
14404
    alternateClassName: 'Ext.grid.MinovaGrid',
14405
    //controller:'orm-manage2-controller',
14406
    tableName: undefined,
14407
    isLookup: undefined,
14408
    param: undefined,
14409
    pagesize: undefined,
14410
    storename: undefined,
14411
    layoutType: undefined,
14412
    enableLocking: true,
14413
    autoLoad: undefined,
14414
    multiSelect: undefined,
14415
    getTableName: function () {
14416
        return this.tableName;
14417
    },
14418

    
14419
    initComponent: function () {
14420
        var me = this;
14421
        var cols_ = [];
14422
        var fieldeditor = {};
14423
        var hasil = null;
14424
        var autoLoad = true;
14425
        var LangID = localStorage.LangId;
14426
        var fielGrid = 'rec.GridView == 1';
14427
        var locking = true;
14428
        var checkSelection = '';
14429
        var widthLock = 250;
14430
        if (me.multiSelect) {
14431
            locking = false;
14432
            checkSelection = 'checkboxmodel';
14433
            widthLock = 40;
14434
        }
14435
        //var _url = 'GetAllField';
14436
        if (me.autoLoad == false) {
14437
            autoLoad = false;
14438
        }
14439
        parameter = null;
14440
        if (me.isLookup == 1 || me.isLookup == 'Y' || me.isLookup == true) {
14441
            parameter = "LangID='" + LangID + "',TableName='" + me.tableName + "',LookupGrid='1'";
14442
            fielGrid = 'rec.LookupGrid == 1';
14443
            locking = false;
14444

    
14445
        } else {
14446
            parameter = "LangID='" + LangID + "',TableName='" + me.tableName + "'"
14447
            //autoLoad = false;
14448
            //_url = 'GetAllFieldGridLookUp';
14449
        };
14450

    
14451
        //Ext.Ajax.request({
14452
        //	async : false,
14453
        //	method : 'POST',
14454
        //	url : '/Devt/' + _url + '?tableName=' + me.tableName,
14455
        //	success : function (response) {
14456
        //		var results = Ext.decode(response.responseText);
14457
        //		hasil = results.data;
14458
        //	}
14459
        //});
14460
        //hamid03102016
14461

    
14462
        Ext.Ajax.request({
14463
            async: false,
14464
            method: 'POST',
14465
            url: '/UserControl/GetStore',
14466
            params: {
14467
                tableName: 'PDSBS0007',
14468
                param: parameter
14469
            },
14470
            success: function (response) {
14471
                var results = Ext.decode(response.responseText);
14472
                hasil = results.data;
14473
            }
14474
        });
14475
        //end
14476

    
14477
        if (hasil.length > 0) {
14478

    
14479
            Ext.each(hasil, function (rec) {
14480
                var null_ = null;
14481
                if (rec.IsPrimaryKey == true) {
14482
                    null_ = false;
14483
                }
14484
                if (rec.IsRequired == true) {
14485
                    null_ = false;
14486
                } else {
14487
                    null_ = true;
14488
                }
14489

    
14490
                if (me.isLookup == 1 || me.isLookup == 'Y' || me.isLookup == true) {
14491
                    if (rec.LookupGrid == 1) {
14492
                        switch (rec.FormatRef) {
14493
                            case "file":
14494
                                cols_.push({
14495
                                    xtype: 'minovapicturecolumn',
14496
                                    text: rec.HeaderTitle,
14497
                                    dataIndex: rec.FieldName,
14498
                                    width: 100,
14499
                                    //filter: {
14500
                                    //    type: 'image',
14501
                                    //    itemDefaults: {
14502
                                    //        emptyText: 'Search for...'
14503
                                    //    }
14504
                                    //}
14505
                                });
14506
                                break
14507
                            case "date":
14508
                                cols_.push({
14509
                                    xtype: 'minovadatecolumn',
14510
                                    text: rec.HeaderTitle,
14511
                                    dataIndex: rec.FieldName,
14512
                                    width: 100,
14513
                                    filter: {
14514
                                        type: 'date',
14515
                                        itemDefaults: {
14516
                                            emptyText: 'Search for...'
14517
                                        }
14518
                                    }
14519
                                });
14520
                                break
14521
                            case "amount":
14522
                                cols_.push({
14523
                                    xtype: 'minovacurrancycolumn',
14524
                                    text: rec.HeaderTitle,
14525
                                    align: 'right',
14526
                                    dataIndex: rec.FieldName,
14527
                                    width: 100,
14528
                                    filter: {
14529
                                        type: 'number',
14530
                                        itemDefaults: {
14531
                                            emptyText: 'Search for...'
14532
                                        }
14533
                                    }
14534
                                });
14535
                                break
14536
                            case "amountencrypt":
14537
                                cols_.push({
14538
                                    xtype: 'minovaamountcolumn',
14539
                                    align: 'right',
14540
                                    text: rec.HeaderTitle,
14541
                                    dataIndex: rec.FieldName,
14542
                                    width: 100,
14543
                                    filter: {
14544
                                        type: 'string',
14545
                                        itemDefaults: {
14546
                                            emptyText: 'Search for...'
14547
                                        }
14548
                                    }
14549
                                });
14550
                                break
14551
                            case "datetime":
14552
                                cols_.push({
14553
                                    xtype: 'minovadatetimecolumn',
14554
                                    text: rec.HeaderTitle,
14555
                                    dataIndex: rec.FieldName,
14556
                                    width: 140,
14557
                                    filter: {
14558
                                        type: 'string',
14559
                                        itemDefaults: {
14560
                                            emptyText: 'Search for...'
14561
                                        }
14562
                                    }
14563
                                });
14564
                                break
14565
                            default:
14566
                                if (rec.DataRef == 'CREATEBY' || rec.DataRef == 'CHANGEBY') {
14567
                                    cols_.push({
14568
                                        text: rec.HeaderTitle,
14569
                                        dataIndex: rec.FieldName,
14570
                                        width: 100,
14571
                                        filter: {
14572
                                            type: 'string',
14573
                                            itemDefaults: {
14574
                                                emptyText: 'Search for...'
14575
                                            }
14576
                                        }
14577
                                    });
14578
                                } else if (rec.SearchType == '2') {
14579
                                    cols_.push({
14580
                                        xtype: 'minovalookupcolumn',
14581
                                        text: rec.HeaderTitle,
14582
                                        tableName: rec.TableRef,
14583
                                        dataIndex: rec.FieldName,
14584
                                        filter: {
14585
                                            itemDefaults: {
14586
                                                emptyText: 'Search for...'
14587
                                            }
14588
                                        }
14589
                                    });
14590
                                } else if (rec.TableRef != "") {
14591
                                    if (rec.TableRef != null) {
14592
                                        var valueField = null;
14593
                                        var displayValue = null;
14594
                                        Ext.Ajax.request({
14595
                                            async: false,
14596
                                            method: 'POST',
14597
                                            url: '/UserControl/GetStore',
14598
                                            params: {
14599
                                                tableName: 'SDATATABLEFIELD',
14600
                                                param: 'TableName[equal]' + rec.TableRef
14601
                                            },
14602
                                            success: function (response) {
14603
                                                var results = Ext.decode(response.responseText);
14604
                                                data_ = results.data;
14605
                                                if (data_ != undefined) {
14606
                                                    valueField_ = $.grep(data_, function (r) {
14607
                                                        return r.ValueField == '1'
14608
                                                    });
14609
                                                    valueField = valueField_[0].FieldName
14610
                                                    displayValue_ = $.grep(data_, function (r) {
14611
                                                        return r.DisplayValue == '1'
14612
                                                    });
14613
                                                    displayValue = displayValue_[0].FieldName
14614
                                                }
14615
                                            }
14616
                                        });
14617
                                        var store_ = Ext.StoreMgr.lookup('store_' + rec.FieldName);
14618
                                        var count_ = 0;
14619
                                        if (store_) {
14620
                                            count_ = store_.count();
14621
                                        }
14622
                                        if (count_ == 0) {
14623
                                            Ext.create('Ext.data.Store', {
14624
                                                storeId: 'store_' + rec.FieldName,
14625
                                                //autoLoad: true,
14626
                                                proxy: {
14627
                                                    method: 'POST',
14628
                                                    type: 'ajax',
14629
                                                    url: '/UserControl/GetStore',
14630
                                                    extraParams: {
14631
                                                        tableName: rec.TableRef,
14632
                                                        param: rec.ParamCombo
14633
                                                    },
14634
                                                    reader: {
14635
                                                        type: 'json',
14636
                                                        root: 'data',
14637
                                                        totalProperty: 'data[0].TotalCount'
14638
                                                    }
14639
                                                }
14640
                                            })
14641
                                        }
14642
                                        cols_.push({
14643
                                            xtype: 'minovacombocolumn',
14644
                                            text: rec.HeaderTitle,
14645
                                            dataIndex: rec.FieldName,
14646
                                            valueField: valueField,
14647
                                            displayField: displayValue,
14648
                                            store: 'store_' + rec.FieldName,
14649
                                            filter: {
14650
                                                type: 'list',
14651
                                                itemDefaults: {
14652
                                                    emptyText: 'Search for...'
14653
                                                }
14654
                                            }
14655
                                        });
14656
                                    }
14657

    
14658
                                } else {
14659
                                    cols_.push({
14660
                                        text: rec.HeaderTitle,
14661
                                        dataIndex: rec.FieldName,
14662
                                        filter: {
14663
                                            itemDefaults: {
14664
                                                emptyText: 'Search for...'
14665
                                            }
14666
                                        }
14667
                                    });
14668
                                }
14669
                                break
14670
                        }
14671
                    } else {
14672
                        cols_.push({
14673
                            text: rec.HeaderTitle,
14674
                            dataIndex: rec.FieldName,
14675
                            hidden: true,
14676
                            filter: {
14677
                                itemDefaults: {
14678
                                    emptyText: 'Search for...'
14679
                                }
14680
                            }
14681
                        });
14682
                    }
14683

    
14684
                } else {
14685
                    if (rec.GridView == 1) {
14686
                        switch (rec.FormatRef) {
14687
                            case "file":
14688
                                cols_.push({
14689
                                    xtype: 'minovapicturecolumn',
14690
                                    text: rec.HeaderTitle,
14691
                                    dataIndex: rec.FieldName,
14692
                                    width: 100,
14693
                                    //filter: {
14694
                                    //    type: '',
14695
                                    //    itemDefaults: {
14696
                                    //        emptyText: 'Search for...'
14697
                                    //    }
14698
                                    //}
14699
                                });
14700
                                break
14701
                            case "date":
14702
                                cols_.push({
14703
                                    xtype: 'minovadatecolumn',
14704
                                    text: rec.HeaderTitle,
14705
                                    dataIndex: rec.FieldName,
14706
                                    width: 100,
14707
                                    filter: {
14708
                                        type: 'date',
14709
                                        itemDefaults: {
14710
                                            emptyText: 'Search for...'
14711
                                        }
14712
                                    }
14713
                                });
14714
                                break
14715
                            case "amountencrypt":
14716
                                cols_.push({
14717
                                    xtype: 'minovaamountcolumn',
14718
                                    align: 'right',
14719
                                    text: rec.HeaderTitle,
14720
                                    dataIndex: rec.FieldName,
14721
                                    width: 100,
14722
                                    filter: {
14723
                                        type: 'string',
14724
                                        itemDefaults: {
14725
                                            emptyText: 'Search for...'
14726
                                        }
14727
                                    }
14728
                                });
14729
                                break
14730
                            case "amount":
14731
                                cols_.push({
14732
                                    text: rec.HeaderTitle,
14733
                                    dataIndex: rec.FieldName,
14734
                                    width: 100,
14735
                                    filter: {
14736
                                        type: 'number',
14737
                                        itemDefaults: {
14738
                                            emptyText: 'Search for...'
14739
                                        }
14740
                                    }
14741
                                });
14742
                                break
14743
                            case "datetime":
14744
                                cols_.push({
14745
                                    xtype: 'minovadatetimecolumn',
14746
                                    text: rec.HeaderTitle,
14747
                                    dataIndex: rec.FieldName,
14748
                                    width: 140,
14749
                                    filter: {
14750
                                        type: 'string',
14751
                                        itemDefaults: {
14752
                                            emptyText: 'Search for...'
14753
                                        }
14754
                                    }
14755
                                });
14756
                                break
14757
                            default:
14758
                                if (rec.DataRef == 'CREATEBY' || rec.DataRef == 'CHANGEBY') {
14759
                                    cols_.push({
14760
                                        text: rec.HeaderTitle,
14761
                                        dataIndex: rec.FieldName,
14762
                                        width: 100,
14763
                                        filter: {
14764
                                            type: 'string',
14765
                                            itemDefaults: {
14766
                                                emptyText: 'Search for...'
14767
                                            }
14768
                                        }
14769
                                    });
14770
                                } else if (rec.SearchType == '2') {
14771
                                    cols_.push({
14772
                                        xtype: 'minovalookupcolumn',
14773
                                        text: rec.HeaderTitle,
14774
                                        tableName: rec.TableRef,
14775
                                        dataIndex: rec.FieldName,
14776
                                        filter: {
14777
                                            itemDefaults: {
14778
                                                emptyText: 'Search for...'
14779
                                            }
14780
                                        }
14781
                                    });
14782
                                } else if (rec.TableRef != "" && rec.SearchType != '2') {
14783
                                    if (rec.TableRef != null) {
14784
                                        var valueField = null;
14785
                                        var displayValue = null;
14786
                                        Ext.Ajax.request({
14787
                                            async: false,
14788
                                            method: 'POST',
14789
                                            url: '/UserControl/GetStore',
14790
                                            params: {
14791
                                                tableName: 'SDATATABLEFIELD',
14792
                                                param: 'TableName[equal]' + rec.TableRef
14793
                                            },
14794
                                            success: function (response) {
14795
                                                var results = Ext.decode(response.responseText);
14796
                                                data_ = results.data;
14797
                                                //if (data_ != undefined) {
14798
                                                if (data_.length > 0) {
14799
                                                    valueField_ = $.grep(data_, function (r) {
14800
                                                        return r.ValueField == '1'
14801
                                                    });
14802
                                                    valueField = valueField_[0].FieldName
14803
                                                    displayValue_ = $.grep(data_, function (r) {
14804
                                                        return r.DisplayValue == '1'
14805
                                                    });
14806
                                                    displayValue = displayValue_[0].FieldName
14807
                                                } else {
14808
                                                    MinovaMessage('Not Null', 'BSNULLCOMBO', rec.TableRef, 'E');
14809
                                                }
14810
                                            }
14811
                                        });
14812
                                        var store_ = Ext.StoreMgr.lookup('store_' + rec.FieldName);
14813
                                        var count_ = 0;
14814
                                        if (store_) {
14815
                                            count_ = store_.count();
14816
                                        }
14817
                                        if (count_ == 0) {
14818
                                            var paramFilter = rec.ParamCombo;
14819
                                            if (rec.TableRef.toLowerCase() == 'phrom0001' && rec.ParamCombo.length == 1) {
14820
                                                paramFilter = 'ObjectClass[=]' + paramFilter;
14821
                                            }
14822
                                            Ext.create('Ext.data.Store', {
14823
                                                storeId: 'store_' + rec.FieldName,
14824
                                                autoLoad: false,
14825
                                                proxy: {
14826
                                                    method: 'POST',
14827
                                                    type: 'ajax',
14828
                                                    url: '/UserControl/GetStore',
14829
                                                    extraParams: {
14830
                                                        tableName: rec.TableRef,
14831
                                                        param: paramFilter
14832
                                                    },
14833
                                                    reader: {
14834
                                                        type: 'json',
14835
                                                        root: 'data',
14836
                                                        totalProperty: 'data[0].TotalCount'
14837
                                                    }
14838
                                                }
14839
                                            })
14840
                                        }
14841
                                        cols_.push({
14842
                                            xtype: 'minovacombocolumn',
14843
                                            text: rec.HeaderTitle,
14844
                                            dataIndex: rec.FieldName,
14845
                                            valueField: valueField,
14846
                                            displayField: displayValue,
14847
                                            store: 'store_' + rec.FieldName,
14848
                                            filter: {
14849
                                                type: 'list',
14850
                                                itemDefaults: {
14851
                                                    emptyText: 'Search for...'
14852
                                                }
14853
                                            }
14854
                                        });
14855
                                    }
14856

    
14857
                                } else if (rec.FixedValue != "") {
14858
                                    cols_.push({
14859
                                        xtype: 'minovacombocolumnfixvalue',
14860
                                        text: rec.HeaderTitle,
14861
                                        dataIndex: rec.FieldName,
14862
                                        fixedValue: rec.FixedValue,
14863
                                        filter: {
14864
                                            type: 'list',
14865
                                            itemDefaults: {
14866
                                                emptyText: 'Search for...'
14867
                                            }
14868
                                        }
14869
                                    });
14870
                                } else {
14871
                                    cols_.push({
14872
                                        text: rec.HeaderTitle,
14873
                                        dataIndex: rec.FieldName,
14874
                                        filter: {
14875
                                            itemDefaults: {
14876
                                                emptyText: 'Search for...'
14877
                                            }
14878
                                        }
14879
                                    });
14880
                                }
14881
                                break
14882
                        }
14883
                    } else {
14884
                        cols_.push({
14885
                            text: rec.HeaderTitle,
14886
                            dataIndex: rec.FieldName,
14887
                            hidden: true,
14888
                            filter: {
14889
                                itemDefaults: {
14890
                                    emptyText: 'Search for...'
14891
                                }
14892
                            }
14893
                        });
14894
                    }
14895

    
14896
                }
14897
            });
14898
        };
14899
        var param_ = me.param;
14900
        if (param_ == undefined) {
14901
            param_ = ''
14902
        }
14903
        var jsStoreGrid = new Ext.data.Store({
14904
            storeId: me.storename,
14905
            autoLoad: autoLoad,
14906
            pageSize: me.pagesize,
14907
            proxy: {
14908
                method: 'POST',
14909
                type: 'ajax',
14910
                url: '/UserControl/GetStorePaging',
14911
                extraParams: {
14912
                    tableName: me.tableName,
14913
                    param: param_,
14914
                    //menuId: MinovaUtil.GetMenuID()
14915
                },
14916
                reader: {
14917
                    type: 'json',
14918
                    root: 'data',
14919
                    totalProperty: 'totalRecords'
14920
                }
14921
            },
14922
        });
14923
        Ext.applyIf(me, {
14924
            autoScroll: true,
14925
            enableLocking: locking,
14926
            lockedGridConfig: {
14927
                header: false,
14928
                collapsible: true,
14929
                width: widthLock,
14930
                forceFit: locking,
14931
                listeners: {
14932
                    render: function (grid) {
14933
                        var pagingToolbar = grid.child('pagingtoolbar');
14934
                        if (pagingToolbar) {
14935
                            grid.remove(pagingToolbar, true);
14936
                        }
14937
                    }
14938
                }
14939
            },
14940
            listeners: {
14941
                viewready: function () {
14942
                    if (autoLoad == true) {
14943
                        this.getStore().loadPage(1);
14944
                    }
14945

    
14946
                },
14947
                beforeedit: function () {
14948
                    return false;
14949
                }
14950
            },
14951
            lockedViewConfig: {
14952
                scroll: 'horizontal'
14953
            },
14954
            viewConfig: {
14955
                emptyText: 'No Data Display',
14956
                deferEmptyText: false,
14957
                //Add Nana For Autosize Column Mode Grid MD
14958
                listeners: {
14959
                    refresh: function (dataview) {
14960
                        Ext.each(dataview.panel.columns, function (column) {
14961
                            if (column.autoSizeColumn == false)
14962
                                column.autoSizeColumn = true;
14963
                            column.autoSize();
14964
                            console.log('GridMD');
14965
                        })
14966
                    },
14967
                    //afterrender: function (dataview) {
14968
                    //	console.log(dataview);
14969
                    //	dataview.getStore().reload();
14970
                    //}
14971
                    afterrender: function (dataview) {
14972
                        Ext.defer(function () {
14973
                            dataview.store.reload();
14974
                        }, 2500, this);
14975
                    }
14976
                }
14977
            },
14978
            //for chekbox
14979
            selModel: {
14980
                //type: 'cellmodel'
14981
            },
14982
            selType: checkSelection,
14983
            columns: cols_,
14984
            store: jsStoreGrid,
14985
            plugins: [{
14986
                ptype: 'gridfilters'
14987
            }
14988
            ],
14989

    
14990
        });
14991
        me.callParent(arguments);
14992
    }
14993

    
14994
});
14995

    
14996
Ext.define('MinovaUtil.MinovaES.MinovaPMSEditAbleGrid', {
14997
    extend: 'Ext.form.Panel',
14998
    alias: ['widget.MinovaPMSEditAbleGrid', 'widget.Minovapmseditablegrid', 'widget.minovapmseditablegrid'],
14999
    requires: [
15000
		'Ext.grid.plugin.CellEditing',
15001
		'Ext.grid.Panel',
15002
    ],
15003
    anchor: '100%',
15004
    tableName: undefined,
15005
    apprasalType: undefined,
15006
    empID: undefined,
15007
    hideButton: undefined,
15008
    multiSelect: undefined,
15009
    initComponent: function () {
15010
        var me = this;
15011
        var isLookup = me.isLookup;
15012
        var hide_ = false;
15013
        var widthLock = 250;
15014
        var checkSelection = '';
15015
        if (me.hideButton == true) {
15016
            hide_ = true;
15017
        }
15018
        if (me.multiSelect) {
15019
            locking = false;
15020
            checkSelection = 'checkboxmodel';
15021
            widthLock = 40;
15022
        }
15023
        var tableName = me.tableName;
15024
        var cols = [];
15025
        var fieldStore = [];
15026
        var _url = 'GetAllField';
15027
        var hasil = null;
15028
        var height = me.height;
15029
        var storeID = 'store' + me.tableName;
15030
        var gridName = 'grid' + me.name;
15031
        if (me.storeName) {
15032
            storeID = me.storeName;
15033
        }
15034
        var empID = me.empID;
15035
        var apprasalType = me.apprasalType;
15036
        var LangID = MinovaUtil.GetLangID();
15037
        var parameter = "LangID='" + LangID + "',TableName='" + me.tableName + "'" + "," + empID + "," + apprasalType
15038
        Ext.Ajax.request({
15039
            async: false,
15040
            method: 'POST',
15041
            url: '/Performance/getFieldPMS',
15042
            params: {
15043
                tableName: 'PDSPMS001',
15044
                _param: parameter
15045
            },
15046
            success: function (response) {
15047
                var results = Ext.decode(response.responseText);
15048
                hasil = Ext.decode(results.data);
15049
            }
15050
        });
15051
        var addData = 'var data={';
15052
        if (hasil.length > 0) {
15053
            Ext.each(hasil, function (rec) {
15054
                fieldStore.push(rec.FieldName)
15055
                if (rec.FieldName != 'Sequence') {
15056
                    addData = addData + rec.FieldName + ":" + "'',";
15057
                }
15058
                var null_ = null;
15059
                var ReadOnly_ = false;
15060
                if (rec.IsPrimaryKey == true) {
15061
                    null_ = false;
15062
                }
15063
                if (rec.IsRequired == true) {
15064
                    null_ = false;
15065
                } else {
15066
                    null_ = true;
15067
                }
15068
                if (rec.ReadOnly == '1') {
15069
                    ReadOnly_ = true;
15070
                }
15071
                var Hidden_ = false;
15072
                if (rec.IsHidden == '1' || rec.Sequence == '' || rec.Sequence == '0' || rec.ColumnNo == '' || rec.GridView == '') {
15073
                    Hidden_ = true;
15074
                    null_ = true;
15075
                }
15076
                if (rec.GridView == 1) {
15077
                    switch (rec.FormatRef) {
15078
                        case "date":
15079
                            cols.push({
15080
                                xtype: 'minovadatecolumn',
15081
                                hidden: Hidden_,
15082
                                text: rec.HeaderTitle,
15083
                                dataIndex: rec.FieldName,
15084
                                filter: {
15085
                                    itemDefaults: {
15086
                                        emptyText: 'Search for...',
15087
                                    }
15088
                                },
15089
                                editor: {
15090
                                    allowBlank: null_,
15091
                                    xtype: 'datefield',
15092
                                    hideMode: 'visibility',
15093
                                    readOnly: ReadOnly_,
15094
                                    id: tableName + rec.FieldName,
15095
                                    fieldGrid: rec.FieldName,
15096
                                    nameTable: rec.TableName,
15097
                                }
15098
                            });
15099
                            break
15100
                        case "amount":
15101
                            cols.push({
15102
                                xtype: 'minovacurrancycolumn',
15103
                                //renderer: Ext.util.Format.numberRenderer("0,0"),
15104
                                text: rec.HeaderTitle,
15105
                                align: 'right',
15106
                                dataIndex: rec.FieldName,
15107
                                hidden: Hidden_,
15108
                                filter: {
15109
                                    itemDefaults: {
15110
                                        emptyText: 'Search for...'
15111
                                    }
15112
                                },
15113
                                editor: {
15114
                                    allowBlank: null_,
15115
                                    xtype: 'minovacurrencyfield',
15116
                                    //renderer: Ext.util.Format.numberRenderer("0,0"),
15117
                                    //vtype: 'validateDecimal',
15118
                                    readOnly: ReadOnly_,
15119
                                    id: tableName + rec.FieldName,
15120
                                    nameTable: rec.TableName,
15121
                                    fieldGrid: rec.FieldName,
15122
                                    fieldStyle: 'text-align:right;',
15123
                                    value: '0',
15124

    
15125
                                }
15126
                            });
15127
                            break
15128
                        case "time":
15129
                            var DefaultValue = rec.DefaultValue;
15130
                            if (DefaultValue == '') {
15131
                                defaultValue = '00:00';
15132
                            }
15133
                            cols.push({
15134
                                //xtype: 'minovatimecolumn',
15135
                                xtype: 'timefield',
15136
                                format: 'H:i',
15137
                                submitFormat: 'Hi',
15138
                                text: rec.HeaderTitle,
15139
                                dataIndex: rec.FieldName,
15140
                                hidden: Hidden_,
15141
                                //renderer: Ext.util.Format.dateRenderer('G:i'),
15142
                                filter: {
15143
                                    itemDefaults: {
15144
                                        emptyText: 'Search for...'
15145
                                    }
15146
                                },
15147
                                editor: {
15148
                                    allowBlank: null_,
15149
                                    xtype: 'timefield',
15150
                                    readOnly: ReadOnly_,
15151
                                    id: tableName + rec.FieldName,
15152
                                    format: 'H:i',
15153
                                    submitFormat: 'Hi',
15154
                                    increment: 5,
15155
                                    value: DefaultValue,
15156
                                    anchor: '100%',
15157
                                    listeners: {}
15158
                                    //renderer: Ext.util.Format.dateRenderer('G:i'),
15159
                                }
15160
                            });
15161
                            break
15162
                        default:
15163
                            if (rec.DataRef == 'CREATEBY' || rec.DataRef == 'CHANGEBY' || rec.DataRef == 'CREATEDT' || rec.DataRef == 'CHANGEDT') {
15164
                                cols.push({
15165
                                    text: rec.HeaderTitle,
15166
                                    dataIndex: rec.FieldName,
15167
                                    width: 100,
15168
                                    filter: {
15169
                                        type: 'string',
15170
                                        itemDefaults: {
15171
                                            emptyText: 'Search for...'
15172
                                        }
15173
                                    }
15174
                                });
15175
                            } else if (rec.SearchType == '0') {
15176
                                var valueField = null;
15177
                                var displayValue = null;
15178
                                var TableRef = undefined;
15179
                                if (rec.TableRef != '') {
15180
                                    TableRef = rec.TableRef;
15181

    
15182
                                    Ext.Ajax.request({
15183
                                        async: false,
15184
                                        method: 'POST',
15185
                                        url: '/UserControl/GetStore',
15186
                                        params: {
15187
                                            tableName: 'SDATATABLEFIELD',
15188
                                            param: 'TableName[equal]' + rec.TableRef
15189
                                        },
15190
                                        success: function (response) {
15191
                                            var results = Ext.decode(response.responseText);
15192
                                            data_ = results.data;
15193
                                            if (data_ != undefined) {
15194
                                                valueField_ = $.grep(data_, function (r) {
15195
                                                    return r.ValueField == '1'
15196
                                                });
15197
                                                valueField = valueField_[0].FieldName
15198
                                                displayValue_ = $.grep(data_, function (r) {
15199
                                                    return r.DisplayValue == '1'
15200
                                                });
15201
                                                displayValue = displayValue_[0].FieldName
15202
                                            }
15203
                                        }
15204
                                    });
15205

    
15206
                                    //create Store
15207
                                    Ext.create('Ext.data.Store', {
15208
                                        storeId: 'store_' + me.tableName + rec.FieldName,
15209
                                        autoLoad: true,
15210
                                        proxy: {
15211
                                            method: 'POST',
15212
                                            type: 'ajax',
15213
                                            url: '/UserControl/GetStore',
15214
                                            extraParams: {
15215
                                                tableName: TableRef,
15216
                                                param: rec.ParamCombo
15217
                                            },
15218
                                            reader: {
15219
                                                type: 'json',
15220
                                                root: 'data',
15221
                                                totalProperty: 'data[0].TotalCount'
15222
                                            }
15223
                                        }
15224
                                    });
15225
                                } else if (rec.FixedValue != '') {
15226
                                    var storeData = [];
15227
                                    var str = rec.FixedValue;
15228
                                    var hasil = str.split('||');
15229
                                    hasil.forEach(function (h) {
15230
                                        store_ = h.split('=')
15231
                                        storeData.push({
15232
                                            code: store_[0],
15233
                                            desc: store_[1],
15234

    
15235
                                        });
15236
                                    });
15237

    
15238
                                    valueField = 'code';
15239
                                    displayValue = 'desc';
15240

    
15241
                                    Ext.create('Ext.data.Store', {
15242
                                        storeId: 'store_' + me.tableName + rec.FieldName,
15243
                                        autoLoad: true,
15244
                                        data: storeData
15245
                                    })
15246
                                }
15247

    
15248
                                cols.push({
15249
                                    xtype: 'minovacombocolumn',
15250
                                    hidden: Hidden_,
15251
                                    text: rec.HeaderTitle,
15252
                                    dataIndex: rec.FieldName,
15253
                                    valueField: valueField,
15254
                                    displayField: displayValue,
15255
                                    store: 'store_' + me.tableName + rec.FieldName,
15256
                                    editor: {
15257
                                        allowBlank: null_,
15258
                                        xtype: 'combobox',
15259
                                        readOnly: ReadOnly_,
15260
                                        id: tableName + rec.FieldName,
15261
                                        nameTable: rec.TableName,
15262
                                        fieldGrid: rec.FieldName,
15263
                                        valueField: valueField,
15264
                                        displayField: displayValue,
15265

    
15266
                                        store: 'store_' + me.tableName + rec.FieldName,
15267
                                    },
15268
                                    filter: {
15269
                                        type: 'list',
15270
                                        itemDefaults: {
15271
                                            emptyText: 'Search for...'
15272
                                        }
15273
                                    }
15274
                                });
15275
                            } else if (rec.SearchType == '5') {							
15276
                                var valueField = null;
15277
                                var displayValue = null;
15278
                                var AdditionaldisplayValue = null;
15279
                                var TableRef = undefined;
15280
                                if (rec.TableRef != '') {
15281
                                    TableRef = rec.TableRef;
15282
                                    Ext.Ajax.request({
15283
                                        async: false,
15284
                                        method: 'POST',
15285
                                        url: '/UserControl/GetStore',
15286
                                        params: {
15287
                                            tableName: 'SDATATABLEFIELD',
15288
                                            param: 'TableName[equal]' + rec.TableRef
15289
                                        },
15290
                                        success: function (response) {
15291
                                            var results = Ext.decode(response.responseText);
15292
                                            data_ = results.data;
15293
                                            if (data_ != undefined) {
15294
                                                valueField_ = $.grep(data_, function (r) {
15295
                                                    return r.ValueField == '1'
15296
                                                });
15297
                                                if (valueField_.length > 0) {
15298
                                                    valueField = valueField_[0].FieldName
15299
                                                }
15300

    
15301
                                                displayValue_ = $.grep(data_, function (r) {
15302
                                                    return r.DisplayValue == '1' || r.DisplayValue == '2'
15303
                                                });
15304
                                                if (displayValue_.length > 0) {
15305
                                                    displayValue = displayValue_[0].FieldName;
15306
                                                }
15307
                                                if (displayValue_.length >= 2) {
15308
                                                    AdditionaldisplayValue = displayValue_[1].FieldName
15309
                                                }
15310
                                            }
15311
                                        }
15312
                                    });
15313
                                }
15314
                                Ext.create('Ext.data.Store', {
15315
                                    storeId: 'store_' + me.tableName + rec.FieldName,
15316
                                    autoLoad: true,
15317
                                    proxy: {
15318
                                        method: 'POST',
15319
                                        type: 'ajax',
15320
                                        url: '/UserControl/GetStoreAuth',
15321
                                        extraParams: {
15322
                                            tableName: TableRef,
15323
                                            param: rec.ParamCombo,
15324
                                            menuId: MinovaUtil.GetMenuID()
15325
                                        },
15326
                                        reader: {
15327
                                            type: 'json',
15328
                                            root: 'data',
15329
                                            totalProperty: 'data[0].TotalCount'
15330
                                        }
15331
                                    }
15332
                                });
15333
                                cols.push({
15334
                                    xtype : 'minovacombocolumn',
15335
                                    hidden: Hidden_,
15336
                                    text: rec.HeaderTitle,
15337
                                    dataIndex: rec.FieldName,
15338
                                    valueField : valueField,
15339
                                    displayField : displayValue,
15340
                                    store : 'store_' + me.tableName + rec.FieldName,
15341
                                    tpl: Ext.create('Ext.XTemplate',
15342
                                            '<ul class="x-list-plain"><tpl for=".">',
15343
                                            '<li role="option" class="x-boundlist-item">{' + AdditionaldisplayValue + '} - {' + displayValue + '}</li>',
15344
                                            '</tpl></ul>'),
15345
                                    displayTpl: Ext.create('Ext.XTemplate',
15346
                                        '<tpl for=".">',
15347
                                        '{' + AdditionaldisplayValue + '} - {' + displayValue + '}',
15348
                                        '</tpl>'),
15349
                                    editor: {
15350
                                        allowBlank: null_,
15351
                                        xtype: 'combobox',
15352
                                        readOnly: ReadOnly_,
15353
                                        id: rec.TableName + rec.FieldName,
15354
                                        nameTable: rec.TableName,
15355
                                        fieldGrid: rec.FieldName,
15356
                                        valueField: valueField,
15357
                                        displayField: displayValue,
15358
                                        store: 'store_' + me.tableName + rec.FieldName,
15359
                                        value: rec.DefaultValue,
15360
                                        tpl: Ext.create('Ext.XTemplate',
15361
                                            '<ul class="x-list-plain"><tpl for=".">',
15362
                                            '<li role="option" class="x-boundlist-item">{' + AdditionaldisplayValue + '} - {' + displayValue + '}</li>',
15363
                                            '</tpl></ul>'),
15364
                                        displayTpl: Ext.create('Ext.XTemplate',
15365
                                            '<tpl for=".">',
15366
                                            '{' + AdditionaldisplayValue + '} - {' + displayValue + '}',
15367
                                            '</tpl>')
15368
                                    },
15369
                                    renderer: function (value) {
15370
                                        var store = Ext.data.StoreManager.lookup('store_' + me.tableName + rec.FieldName);
15371
                                        var index = store.find(valueField, value);
15372
                                        var val = "";
15373
                                        if (index != -1) {
15374
                                            var rc = store.getAt(index);
15375
                                            //val = rc.get(displayValue);
15376
                                            val = rc.get(AdditionaldisplayValue) + ' - ' + rc.get(displayValue);
15377
                                        } else {
15378
                                            val = value;
15379
                                        }
15380
                                        return val;
15381
                                    },
15382
                                    filter: {
15383
                                        type: 'list',
15384
                                        itemDefaults: {
15385
                                            emptyText: 'Search for...'
15386
                                        }
15387
                                    }
15388
                                });
15389
                            } else if (rec.SearchType == '2') {
15390
                                var triger = (rec.TriggerCombo).split('$');
15391
                                var targetField_ = triger[0];
15392
                                var fieldValue_ = triger[1];
15393
                                cols.push({
15394
                                    text: rec.HeaderTitle,
15395
                                    hidden: Hidden_,
15396
                                    dataIndex: rec.FieldName,
15397
                                    filter: {
15398
                                        itemDefaults: {
15399
                                            emptyText: 'Search for...'
15400
                                        }
15401
                                    },
15402
                                    editor: {
15403
                                        allowBlank: null_,
15404
                                        xtype: 'minovalookupgrid',
15405
                                        readOnly: ReadOnly_,
15406
                                        isGrid: true,
15407
                                        fieldTarget: targetField_,
15408
                                        fieldValue: fieldValue_,
15409
                                        isGrid: true,
15410
                                        id: tableName + rec.FieldName,
15411
                                        tableName: rec.TableRef, //name tabel yang jadi ref-nya
15412
                                        triggerCls: 'x-form-search-trigger',
15413
                                        vtype: 'alphanum', // disable space
15414
                                        nameTable: rec.TableName,
15415
                                        fieldGrid: rec.FieldName,
15416
                                        LookupFunction: rec.LookupFunction,
15417
                                        listeners: {
15418
                                            change: function (val) {
15419
                                                var custumFunc = rec.SelectFunction;
15420
                                                if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
15421
                                                    Ext.Ajax.request({
15422
                                                        async: false,
15423
                                                        method: 'POST',
15424
                                                        url: '/UserControl/GetStore',
15425
                                                        params: {
15426
                                                            tableName: 'PCMFUNC',
15427
                                                            param: 'FuncName[equal]' + rec.custumFunc + ',Active[=]1'
15428
                                                        },
15429
                                                        success: function (response) {
15430
                                                            var results = Ext.decode(response.responseText);
15431
                                                            data_ = results.data[0];
15432
                                                            if (data_ != undefined) {
15433
                                                                custumFunc = data_.FunctionCode;
15434
                                                            }
15435
                                                        }
15436
                                                    });
15437
                                                }
15438
                                                if (custumFunc) {
15439
                                                    eval(custumFunc)
15440
                                                }
15441
                                            }
15442
                                        }
15443
                                    }
15444
                                });
15445
                            } else if (rec.SearchType == '3') {
15446
                                cols.push({
15447
                                    text: rec.HeaderTitle,
15448
                                    hidden: Hidden_,
15449
                                    dataIndex: rec.FieldName,
15450
                                    filter: {
15451
                                        itemDefaults: {
15452
                                            emptyText: 'Search for...'
15453
                                        }
15454
                                    },
15455
                                    editor: {
15456
                                        allowBlank: null_,
15457
                                        // xtype: 'minovalookuptreePopup',
15458
                                        xtype: 'MinovaLookupTree',
15459
                                        readOnly: ReadOnly_,
15460
                                        id: tableName + rec.FieldName,
15461
                                        tableName: rec.TableRef, //name tabel yang jadi ref-nya
15462
                                        triggerCls: 'x-form-search-trigger',
15463
                                        vtype: 'alphanum', // disable space
15464
                                        treeSructure: rec.SearchFunction, //'O-O-P',
15465
                                        objClassValue: rec.ParamCombo, //'O',
15466
                                        nameTable: rec.TableName,
15467
                                        fieldGrid: rec.FieldName,
15468
                                        listeners: {
15469
                                            change: function (val) {
15470
                                                var custumFunc = rec.SelectFunction;
15471
                                                if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
15472
                                                    Ext.Ajax.request({
15473
                                                        async: false,
15474
                                                        method: 'POST',
15475
                                                        url: '/UserControl/GetStore',
15476
                                                        params: {
15477
                                                            tableName: 'PCMFUNC',
15478
                                                            param: 'FuncName[equal]' + rec.custumFunc + ',Active[=]1'
15479
                                                        },
15480
                                                        success: function (response) {
15481
                                                            var results = Ext.decode(response.responseText);
15482
                                                            data_ = results.data[0];
15483
                                                            if (data_ != undefined) {
15484
                                                                custumFunc = data_.FunctionCode;
15485
                                                            }
15486
                                                        }
15487
                                                    });
15488
                                                }
15489
                                                if (custumFunc) {
15490
                                                    eval(custumFunc)
15491
                                                }
15492
                                            }
15493
                                        }
15494
                                    }
15495
                                });
15496
                            } else if (rec.SearchType != '0' && rec.SearchType != '1' && rec.SearchType != '3' && (rec.FieldName == 'EmployeeID' || rec.FieldName == 'ApplicantID' || rec.FieldName == 'EmployeeIDFrom' || rec.FieldName == 'EmployeeIDTo') && isLookup != true) {
15497
                                var triger = (rec.TriggerCombo).split('&');
15498
                                var targetField_ = triger[0];
15499
                                var fieldValue_ = triger[0];
15500
                                cols.push({
15501
                                    text: rec.HeaderTitle,
15502
                                    hidden: Hidden_,
15503
                                    dataIndex: rec.FieldName,
15504
                                    filter: {
15505
                                        itemDefaults: {
15506
                                            emptyText: 'Search for...'
15507
                                        }
15508
                                    },
15509
                                    editor: {
15510
                                        allowBlank: null_,
15511
                                        xtype: 'lookupemployee',
15512
                                        readOnly: ReadOnly_,
15513
                                        isGrid: true,
15514
                                        fieldTarget: targetField_,
15515
                                        fieldValue: fieldValue_,
15516
                                        isGrid: true,
15517
                                        id: tableName + rec.FieldName,
15518
                                        tableName: rec.TableRef, //name tabel yang jadi ref-nya
15519
                                        triggerCls: 'x-form-search-trigger',
15520
                                        vtype: 'alphanum', // disable space
15521
                                        nameTable: rec.TableName,
15522
                                        fieldGrid: rec.FieldName,
15523
                                        listeners: {
15524
                                            change: function (val) {
15525
                                                var custumFunc = rec.SelectFunction;
15526
                                                if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
15527
                                                    Ext.Ajax.request({
15528
                                                        async: false,
15529
                                                        method: 'POST',
15530
                                                        url: '/UserControl/GetStore',
15531
                                                        params: {
15532
                                                            tableName: 'PCMFUNC',
15533
                                                            param: 'FuncName[equal]' + rec.custumFunc + ',Active[=]1'
15534
                                                        },
15535
                                                        success: function (response) {
15536
                                                            var results = Ext.decode(response.responseText);
15537
                                                            data_ = results.data[0];
15538
                                                            if (data_ != undefined) {
15539
                                                                custumFunc = data_.FunctionCode;
15540
                                                            }
15541
                                                        }
15542
                                                    });
15543
                                                }
15544
                                                if (custumFunc) {
15545
                                                    eval(custumFunc)
15546
                                                }
15547
                                            }
15548
                                        }
15549
                                    }
15550
                                });
15551
                            } else if (rec.SearchType == '4' && isLookup != true) {
15552
                                cols.push({
15553

    
15554
                                    text: rec.HeaderTitle,
15555
                                    hidden: Hidden_,
15556
                                    dataIndex: rec.FieldName,
15557
                                    filter: {
15558
                                        itemDefaults: {
15559
                                            emptyText: 'Search for...'
15560
                                        }
15561
                                    },
15562
                                    editor: {
15563
                                        allowBlank: null_,
15564
                                        xtype: 'lookupemployee',
15565
                                        readOnly: ReadOnly_,
15566
                                        isGrid: true,
15567
                                        fieldTarget: targetField_,
15568
                                        fieldValue: fieldValue_,
15569
                                        isGrid: true,
15570
                                        id: tableName + rec.FieldName,
15571
                                        tableName: rec.TableRef, //name tabel yang jadi ref-nya
15572
                                        triggerCls: 'x-form-search-trigger',
15573
                                        vtype: 'alphanum', // disable space
15574
                                        nameTable: rec.TableName,
15575
                                        fieldGrid: rec.FieldName,
15576
                                        listeners: {
15577
                                            change: function (val) {
15578
                                                var custumFunc = rec.SelectFunction;
15579
                                                if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
15580
                                                    Ext.Ajax.request({
15581
                                                        async: false,
15582
                                                        method: 'POST',
15583
                                                        url: '/UserControl/GetStore',
15584
                                                        params: {
15585
                                                            tableName: 'PCMFUNC',
15586
                                                            param: 'FuncName[equal]' + rec.custumFunc + ',Active[=]1'
15587
                                                        },
15588
                                                        success: function (response) {
15589
                                                            var results = Ext.decode(response.responseText);
15590
                                                            data_ = results.data[0];
15591
                                                            if (data_ != undefined) {
15592
                                                                custumFunc = data_.FunctionCode;
15593
                                                            }
15594
                                                        }
15595
                                                    });
15596
                                                }
15597
                                                if (custumFunc) {
15598
                                                    eval(custumFunc)
15599
                                                }
15600
                                            }
15601
                                        }
15602
                                    }
15603
                                });
15604
                            } else {
15605
                                cols.push({
15606
                                    text: rec.HeaderTitle,
15607
                                    hidden: Hidden_,
15608
                                    dataIndex: rec.FieldName,
15609
                                    filter: {
15610
                                        itemDefaults: {
15611
                                            emptyText: 'Search for...'
15612
                                        }
15613
                                    },
15614
                                    editor: {
15615
                                        allowBlank: null_,
15616
                                        xtype: 'textfield',
15617
                                        readOnly: ReadOnly_,
15618
                                        id: tableName + rec.FieldName,
15619
                                        nameTable: rec.TableName,
15620
                                        fieldGrid: rec.FieldName,
15621
                                        listeners: {
15622
                                            change: function (val) {
15623
                                                var custumFunc = null;
15624
                                                Ext.Ajax.request({
15625
                                                    async: false,
15626
                                                    method: 'POST',
15627
                                                    url: '/UserControl/GetStore',
15628
                                                    params: {
15629
                                                        tableName: 'SDATATABLEFIELD',
15630
                                                        param: 'FieldName[equal]' + rec.FieldName + ',TableName[equal]' + me.tableName
15631
                                                    },
15632
                                                    success: function (response) {
15633
                                                        var results = Ext.decode(response.responseText);
15634
                                                        data_ = results.data[0];
15635
                                                        if (data_ != undefined) {
15636
                                                            custumFunc = data_.SelectFunction;
15637
                                                            //console.log(data_)
15638
                                                        }
15639
                                                    }
15640
                                                });
15641
                                                if (custumFunc) {
15642
                                                    eval(custumFunc)
15643
                                                }
15644
                                            }
15645
                                        }
15646
                                    }
15647
                                });
15648
                            }
15649
                            break
15650
                    }
15651
                } else {
15652
                    cols.push({
15653
                        text: rec.HeaderTitle,
15654
                        hidden: Hidden_,
15655
                        dataIndex: rec.FieldName,
15656
                        hidden: true,
15657
                        editor: {
15658
                            allowBlank: true,
15659
                            xtype: 'textfield',
15660
                            readOnly: ReadOnly_,
15661
                            id: tableName + rec.FieldName,
15662
                            nameTable: rec.TableName,
15663
                            fieldGrid: rec.FieldName,
15664
                        },
15665
                        filter: {
15666
                            itemDefaults: {
15667
                                emptyText: 'Search for...'
15668
                            }
15669
                        }
15670
                    });
15671
                }
15672
            });
15673
        };
15674
        addData = addData + "}";
15675
        Ext.applyIf(me, {
15676

    
15677
            items: [{
15678
                xtype: 'grid',
15679
                id: gridName,
15680
                name: gridName,
15681
                height: height,
15682
                autoHeight: true,
15683
                //store: 'gridStore',
15684
                autoScroll: true,
15685
                store: Ext.create('Ext.data.Store', {
15686
                    storeId: storeID,
15687
                    fields: fieldStore,
15688
                    proxy: {
15689
                        method: 'POST',
15690
                        type: 'ajax',
15691
                        url: '',
15692
                        reader: {
15693
                            type: 'json',
15694
                            root: 'data'
15695
                        }
15696
                    }
15697
                }),
15698
                dockedItems: [{
15699
                    xtype: 'toolbar',
15700
                    items: [{
15701
                        text: 'Add',
15702
                        hidden: hide_,
15703
                        name: tableName + 'Add',
15704
                        iconCls: 'fa-plus-circle',
15705
                        style: 'font-family: FontAwesome',
15706
                        handler: function () {
15707
                            var store = Ext.StoreMgr.lookup(storeID)
15708
                            idx = store.getCount();
15709
                            var action = getParam('action');
15710
                            var data = '';
15711
                            var Sequence = 0;
15712
                            if (idx == 0) {
15713
                                Sequence = 1;
15714
                            } else {
15715
                                Sequence = 1 + idx;
15716
                            }
15717
                            //data = {
15718
                            //    Sequence: Sequence
15719
                            //};
15720

    
15721
                            var seq = 'Sequence';
15722
                            var SequenceValue = Sequence;
15723
                            eval(addData);
15724
                            data[seq] = SequenceValue;
15725

    
15726
                            store.insert(idx, data);
15727
                        }
15728

    
15729
                    }, {
15730
                        text: 'Delete',
15731
                        hidden: hide_,
15732
                        name: tableName + 'DeleteText',
15733
                        iconCls: 'fa-trash-o',
15734
                        style: 'font-family: FontAwesome',
15735
                        //disabled: true
15736
                        handler: function () {
15737
                            var me = this,
15738
                            store = Ext.StoreMgr.lookup(storeID)
15739

    
15740
                            var grid = Ext.getCmp(gridName);
15741

    
15742
                            Ext.MessageBox.show({
15743
                                title: 'Remove tab',
15744
                                msg: "This will remove. Do you want to continue?",
15745
                                buttons: Ext.MessageBox.YESNO,
15746
                                fn: function (choice) {
15747
                                    console.log(choice);
15748
                                    if (choice === 'yes') {
15749
                                        var selection = grid.getView().getSelectionModel().getSelection()[0];
15750
                                        if (selection) {
15751
                                            store.remove(selection);
15752
                                        }
15753
                                    }
15754
                                    //delete panel.pendingClose;
15755
                                }
15756
                            });
15757
                        }
15758

    
15759
                    }
15760
                    ]
15761
                }
15762
                ],
15763
                columns: cols,
15764
                selType: checkSelection,
15765
                //selType: 'rowmodel',
15766
                plugins: {
15767
                    ptype: 'rowediting',
15768
                    pluginId: 'rowEditing',
15769
                    clicksToEdit: 0,
15770
                    listeners: {
15771
                        //edit: 'onGridEditorEdit'
15772
                    }
15773
                }
15774
            }, ]
15775

    
15776
        });
15777

    
15778
        me.callParent(arguments);
15779
    }
15780
});
15781

    
15782
Ext.define('MinovaUtil.MinovaES.Minovatimefield', {
15783
    extend: 'Ext.form.field.Time',
15784
    alias: ['widget.minovatimefield'],
15785
    undefinedText: '&#160;',
15786
    setValue: function (v) {
15787
        hasil = '';
15788
        if (v != this.getValue()) {
15789
            if (v) {
15790
                if (v.length == 4) {
15791

    
15792
                    var h = v.substring(0, 2);
15793
                    var m = v.substring(2, 4)
15794
                    //this.setValue(h +':'+m);
15795
                    hasil = h + ':' + m;
15796
                }
15797
                if (v.length == 5) {
15798
                    this.setValue(v);
15799
                    hasil = v;
15800
                }
15801
            }
15802
            this.setValue(hasil);
15803
        }
15804

    
15805
    },
15806
});
15807

    
15808
Ext.define('MinovaUtil.MinovaES.MinovaFixValueLabel', {
15809
    extend: 'Ext.form.Label',
15810
    alias: ['widget.MinovaFixValueLabel', 'widget.minovafixvaluelabel'],
15811
    anchor: '50%',
15812
    defaultRenderer: function (value) {
15813
        if (typeof(this.store) !== 'object') {
15814
            this.store = Ext.data.StoreManager.lookup(this.store);
15815
        }
15816
        var idx = this.store.findExact('code', value);
15817
        if (this.store.getAt(idx)) {
15818
            var result = this.store.getAt(idx).get('desc');
15819
            value = result ? result : value;
15820
        }
15821
        this.setRawValue(value);
15822

    
15823
    },
15824
    initComponent: function () {
15825
        var me = this;
15826
        var storeData = [];
15827
        var str = me.fixedValue;
15828
        var hasil = str.split('||');
15829
        hasil.forEach(function (h) {
15830
            store_ = h.split('=')
15831
            storeData.push({
15832
                code: store_[0],
15833
                desc: store_[1],
15834

    
15835
            });
15836
        });
15837
        Ext.applyIf(me, {
15838

    
15839
            store: Ext.create('Ext.data.Store', {
15840
                storeId: 'store' + name,
15841
                autoLoad: true,
15842
                data: storeData
15843

    
15844
            }),
15845

    
15846
        });
15847
        me.callParent(arguments);
15848
    }
15849
});
15850

    
15851
Ext.define('MinovaUtil.MinovaES.MinovaComboColumnFixValueLabel', {
15852
    extend: 'Ext.grid.column.Column',
15853
    alias: ['widget.minovacombocolumnfixvalue'],
15854
    initComponent: function () {
15855
        var me = this;
15856
        var storeData = [];
15857
        var str = me.fixedValue;
15858
        var hasil = str.split('||');
15859
        hasil.forEach(function (h) {
15860
            store_ = h.split('=')
15861
            storeData.push({
15862
                code: store_[0],
15863
                desc: store_[1],
15864

    
15865
            });
15866
        });
15867
        Ext.applyIf(me, {
15868

    
15869
            store: Ext.create('Ext.data.Store', {
15870
                storeId: 'store' + name,
15871
                autoLoad: true,
15872
                data: storeData
15873

    
15874
            }),
15875

    
15876
        });
15877
        this.callParent(arguments);
15878
    },
15879
    defaultRenderer: function (value) {
15880
        if (typeof(this.store) !== 'object') {
15881
            Ext.data.StoreManager.lookup(this.store).load();
15882
            this.store = Ext.data.StoreManager.lookup(this.store);
15883
        }
15884
        var idx = this.store.findExact('code', value);
15885
        if (this.store.getAt(idx)) {
15886
            var result = this.store.getAt(idx).get('desc');
15887
            value = result ? result : value;
15888
        }
15889
        return value;
15890
    }
15891
});
15892

    
15893
Ext.define('MinovaUtil.MinovaES.MinovaLookupColumn', {
15894
    extend: 'Ext.grid.column.Column',
15895
    alias: ['widget.minovalookupcolumn'],
15896
    initComponent: function () {
15897
        this.callParent(arguments);
15898
    },
15899
    defaultRenderer: function (value) {
15900
        data_ = undefined;
15901
        Ext.Ajax.request({
15902
            async: false,
15903
            method: 'POST',
15904
            url: '/UserControl/GetStore',
15905
            params: {
15906
                tableName: 'PDSCMTABLE',
15907
                param: this.tableName + ',' + value + ',hasil'
15908
            },
15909
            success: function (response) {
15910
                var results = Ext.decode(response.responseText);
15911
                data_ = results.data;
15912
                if (data_ != null) {
15913
                    if (data_.length > 0) {
15914
                        value = value + '-' + data_[0].hasil;
15915
                    }
15916
                }
15917
            }
15918
        });
15919
        return value;
15920
    }
15921
});
15922

    
15923
Ext.define('MinovaUtil.MinovaES.MinovaPMSTreeEditAbleGrid', {
15924
    extend: 'Ext.form.Panel',
15925
    alias: ['widget.MinovaPMSTreeEditAbleGrid', 'widget.Minovapmstreeeditablegrid', 'widget.minovapmstreeeeditablegrid'],
15926
    requires: [
15927
		'Ext.grid.plugin.CellEditing',
15928
		'Ext.grid.Panel',
15929
    ],
15930
    anchor: '100%',
15931
    tableName: undefined,
15932
    apprasalType: undefined,
15933
    empID: undefined,
15934
    hideButton: undefined,
15935
    multiSelect: undefined,
15936
    height: undefined,
15937
    initComponent: function () {
15938
        var me = this;
15939
        var isLookup = me.isLookup;
15940
        var hide_ = false;
15941
        var widthLock = 250;
15942
        var checkSelection = '';
15943
        if (me.hideButton == true) {
15944
            hide_ = true;
15945
        }
15946
        if (me.multiSelect) {
15947
            locking = false;
15948
            checkSelection = 'checkboxmodel';
15949
            widthLock = 40;
15950
        }
15951
        var tableName = me.tableName;
15952
        var cols = [];
15953
        var fieldStore = [];
15954
        var _url = 'GetAllField';
15955
        var hasil = null;
15956
        var height = me.height;
15957
        var storeID = 'store' + me.tableName;
15958
        var gridName = 'grid' + me.tableName;
15959
        if (me.storeName) {
15960
            storeID = me.storeName;
15961
        }
15962
        var empID = me.empID;
15963
        var apprasalType = me.apprasalType;
15964
        var LangID = MinovaUtil.GetLangID();
15965
        var parameter = "LangID='" + LangID + "',TableName='" + me.tableName + "'" + "," + empID + "," + apprasalType
15966
        Ext.Ajax.request({
15967
            async: false,
15968
            method: 'POST',
15969
            url: '/Performance/getFieldPMS',
15970
            params: {
15971
                tableName: 'PDSPMS001',
15972
                _param: parameter
15973
            },
15974
            success: function (response) {
15975
                var results = Ext.decode(response.responseText);
15976
                hasil = Ext.decode(results.data);
15977
            }
15978
        });
15979
        var addData = 'var data={';
15980
        if (hasil.length > 0) {
15981
            Ext.each(hasil, function (rec) {
15982
                fieldStore.push(rec.FieldName)
15983
                if (rec.FieldName != 'Sequence') {
15984
                    addData = addData + rec.FieldName + ":" + "'',";
15985
                }
15986
                var null_ = null;
15987
                var ReadOnly_ = false;
15988
                if (rec.IsPrimaryKey == true) {
15989
                    null_ = false;
15990
                }
15991
                if (rec.IsRequired == true) {
15992
                    null_ = false;
15993
                } else {
15994
                    null_ = true;
15995
                }
15996
                if (rec.ReadOnly == '1') {
15997
                    ReadOnly_ = true;
15998
                }
15999
                var Hidden_ = false;
16000
                if (rec.IsHidden == '1' || rec.Sequence == '' || rec.Sequence == '0' || rec.ColumnNo == '' || rec.GridView == '') {
16001
                    Hidden_ = true;
16002
                    null_ = true;
16003
                }
16004
                if (rec.GridView != 0) {
16005
                    if (rec.GridView == 3) {
16006
                        cols.push({
16007
                            xtype: 'treecolumn',
16008
                            text: rec.HeaderTitle,
16009
                            dataIndex: rec.FieldName,
16010
                            hidden: Hidden_,
16011
                            width: 200,
16012
                            sortable: true,
16013
                            filter: {
16014
                                itemDefaults: {
16015
                                    emptyText: 'Search for...'
16016
                                }
16017
                            }
16018
                        });
16019
                    } else {
16020
                        switch (rec.FormatRef) {
16021
                            case "date":
16022
                                cols.push({
16023
                                    xtype: 'minovadatecolumn',
16024
                                    hidden: Hidden_,
16025
                                    text: rec.HeaderTitle,
16026
                                    dataIndex: rec.FieldName,
16027
                                    filter: {
16028
                                        itemDefaults: {
16029
                                            emptyText: 'Search for...',
16030
                                        }
16031
                                    },
16032
                                    editor: {
16033
                                        allowBlank: null_,
16034
                                        xtype: 'datefield',
16035
                                        hideMode: 'visibility',
16036
                                        readOnly: ReadOnly_,
16037
                                        id: tableName + rec.FieldName,
16038
                                        fieldGrid: rec.FieldName,
16039
                                        nameTable: rec.TableName,
16040
                                    }
16041
                                });
16042
                                break
16043
                            case "amount":
16044
                                cols.push({
16045
                                    xtype: 'minovacurrancycolumn',
16046
                                    //renderer: Ext.util.Format.numberRenderer("0,0"),
16047
                                    text: rec.HeaderTitle,
16048
                                    align: 'right',
16049
                                    dataIndex: rec.FieldName,
16050
                                    hidden: Hidden_,
16051
                                    filter: {
16052
                                        itemDefaults: {
16053
                                            emptyText: 'Search for...'
16054
                                        }
16055
                                    },
16056
                                    editor: {
16057
                                        allowBlank: null_,
16058
                                        xtype: 'minovacurrencyfield',
16059
                                        //renderer: Ext.util.Format.numberRenderer("0,0"),
16060
                                        //vtype: 'validateDecimal',
16061
                                        readOnly: ReadOnly_,
16062
                                        id: tableName + rec.FieldName,
16063
                                        nameTable: rec.TableName,
16064
                                        fieldGrid: rec.FieldName,
16065
                                        fieldStyle: 'text-align:right;',
16066
                                        value: '0',
16067

    
16068
                                    }
16069
                                });
16070
                                break
16071
                            case "time":
16072
                                var DefaultValue = rec.DefaultValue;
16073
                                if (DefaultValue == '') {
16074
                                    defaultValue = '00:00';
16075
                                }
16076
                                cols.push({
16077
                                    //xtype: 'minovatimecolumn',
16078
                                    xtype: 'timefield',
16079
                                    format: 'H:i',
16080
                                    submitFormat: 'Hi',
16081
                                    text: rec.HeaderTitle,
16082
                                    dataIndex: rec.FieldName,
16083
                                    hidden: Hidden_,
16084
                                    //renderer: Ext.util.Format.dateRenderer('G:i'),
16085
                                    filter: {
16086
                                        itemDefaults: {
16087
                                            emptyText: 'Search for...'
16088
                                        }
16089
                                    },
16090
                                    editor: {
16091
                                        allowBlank: null_,
16092
                                        xtype: 'timefield',
16093
                                        readOnly: ReadOnly_,
16094
                                        id: tableName + rec.FieldName,
16095
                                        format: 'H:i',
16096
                                        submitFormat: 'Hi',
16097
                                        increment: 5,
16098
                                        value: DefaultValue,
16099
                                        anchor: '100%',
16100
                                        listeners: {}
16101
                                        //renderer: Ext.util.Format.dateRenderer('G:i'),
16102
                                    }
16103
                                });
16104
                                break
16105
                            default:
16106
                                if (rec.DataRef == 'CREATEBY' || rec.DataRef == 'CHANGEBY' || rec.DataRef == 'CREATEDT' || rec.DataRef == 'CHANGEDT') {
16107
                                    cols.push({
16108
                                        text: rec.HeaderTitle,
16109
                                        dataIndex: rec.FieldName,
16110
                                        width: 100,
16111
                                        filter: {
16112
                                            type: 'string',
16113
                                            itemDefaults: {
16114
                                                emptyText: 'Search for...'
16115
                                            }
16116
                                        }
16117
                                    });
16118
                                } else if (rec.SearchType == '0') {
16119
                                    var valueField = null;
16120
                                    var displayValue = null;
16121
                                    var TableRef = undefined;
16122
                                    if (rec.TableRef != '') {
16123
                                        TableRef = rec.TableRef;
16124

    
16125
                                        Ext.Ajax.request({
16126
                                            async: false,
16127
                                            method: 'POST',
16128
                                            url: '/UserControl/GetStore',
16129
                                            params: {
16130
                                                tableName: 'SDATATABLEFIELD',
16131
                                                param: 'TableName[equal]' + rec.TableRef
16132
                                            },
16133
                                            success: function (response) {
16134
                                                var results = Ext.decode(response.responseText);
16135
                                                data_ = results.data;
16136
                                                if (data_ != undefined) {
16137
                                                    valueField_ = $.grep(data_, function (r) {
16138
                                                        return r.ValueField == '1'
16139
                                                    });
16140
                                                    valueField = valueField_[0].FieldName
16141
                                                    displayValue_ = $.grep(data_, function (r) {
16142
                                                        return r.DisplayValue == '1'
16143
                                                    });
16144
                                                    displayValue = displayValue_[0].FieldName
16145
                                                }
16146
                                            }
16147
                                        });
16148

    
16149
                                        //create Store
16150
                                        Ext.create('Ext.data.Store', {
16151
                                            storeId: 'store_' + me.tableName + rec.FieldName,
16152
                                            autoLoad: true,
16153
                                            proxy: {
16154
                                                method: 'POST',
16155
                                                type: 'ajax',
16156
                                                url: '/UserControl/GetStore',
16157
                                                extraParams: {
16158
                                                    tableName: TableRef,
16159
                                                    param: rec.ParamCombo
16160
                                                },
16161
                                                reader: {
16162
                                                    type: 'json',
16163
                                                    root: 'data',
16164
                                                    totalProperty: 'data[0].TotalCount'
16165
                                                }
16166
                                            }
16167
                                        });
16168
                                    } else if (rec.FixedValue != '') {
16169
                                        var storeData = [];
16170
                                        var str = rec.FixedValue;
16171
                                        var hasil = str.split('||');
16172
                                        hasil.forEach(function (h) {
16173
                                            store_ = h.split('=')
16174
                                            storeData.push({
16175
                                                code: store_[0],
16176
                                                desc: store_[1],
16177

    
16178
                                            });
16179
                                        });
16180

    
16181
                                        valueField = 'code';
16182
                                        displayValue = 'desc';
16183

    
16184
                                        Ext.create('Ext.data.Store', {
16185
                                            storeId: 'store_' + me.tableName + rec.FieldName,
16186
                                            autoLoad: true,
16187
                                            data: storeData
16188
                                        })
16189
                                    }
16190

    
16191
                                    cols.push({
16192
                                        xtype: 'minovacombocolumn',
16193
                                        hidden: Hidden_,
16194
                                        text: rec.HeaderTitle,
16195
                                        dataIndex: rec.FieldName,
16196
                                        valueField: valueField,
16197
                                        displayField: displayValue,
16198
                                        store: 'store_' + me.tableName + rec.FieldName,
16199
                                        editor: {
16200
                                            allowBlank: null_,
16201
                                            xtype: 'combobox',
16202
                                            readOnly: ReadOnly_,
16203
                                            id: tableName + rec.FieldName,
16204
                                            nameTable: rec.TableName,
16205
                                            fieldGrid: rec.FieldName,
16206
                                            valueField: valueField,
16207
                                            displayField: displayValue,
16208

    
16209
                                            store: 'store_' + me.tableName + rec.FieldName,
16210
                                        },
16211
                                        filter: {
16212
                                            type: 'list',
16213
                                            itemDefaults: {
16214
                                                emptyText: 'Search for...'
16215
                                            }
16216
                                        }
16217
                                    });
16218

    
16219
                                } else if (rec.SearchType == '5') {								
16220
                                    var valueField = null;
16221
                                    var displayValue = null;
16222
                                    var AdditionaldisplayValue = null;
16223
                                    var TableRef = undefined;
16224
                                    if (rec.TableRef != '') {
16225
                                        TableRef = rec.TableRef;
16226
                                        Ext.Ajax.request({
16227
                                            async: false,
16228
                                            method: 'POST',
16229
                                            url: '/UserControl/GetStore',
16230
                                            params: {
16231
                                                tableName: 'SDATATABLEFIELD',
16232
                                                param: 'TableName[equal]' + rec.TableRef
16233
                                            },
16234
                                            success: function (response) {
16235
                                                var results = Ext.decode(response.responseText);
16236
                                                data_ = results.data;
16237
                                                if (data_ != undefined) {
16238
                                                    valueField_ = $.grep(data_, function (r) {
16239
                                                        return r.ValueField == '1'
16240
                                                    });
16241
                                                    if (valueField_.length > 0) {
16242
                                                        valueField = valueField_[0].FieldName
16243
                                                    }
16244

    
16245
                                                    displayValue_ = $.grep(data_, function (r) {
16246
                                                        return r.DisplayValue == '1' || r.DisplayValue == '2'
16247
                                                    });
16248
                                                    if (displayValue_.length > 0) {
16249
                                                        displayValue = displayValue_[0].FieldName;
16250
                                                    }
16251
                                                    if (displayValue_.length >= 2) {
16252
                                                        AdditionaldisplayValue = displayValue_[1].FieldName
16253
                                                    }
16254
                                                }
16255
                                            }
16256
                                        });
16257
                                    }
16258
                                    Ext.create('Ext.data.Store', {
16259
                                        storeId: 'store_' + me.tableName + rec.FieldName,
16260
                                        autoLoad: true,
16261
                                        proxy: {
16262
                                            method: 'POST',
16263
                                            type: 'ajax',
16264
                                            url: '/UserControl/GetStoreAuth',
16265
                                            extraParams: {
16266
                                                tableName: TableRef,
16267
                                                param: rec.ParamCombo,
16268
                                                menuId: MinovaUtil.GetMenuID()
16269
                                            },
16270
                                            reader: {
16271
                                                type: 'json',
16272
                                                root: 'data',
16273
                                                totalProperty: 'data[0].TotalCount'
16274
                                            }
16275
                                        }
16276
                                    });
16277
                                    cols.push({
16278
                                        xtype : 'minovacombocolumn',
16279
                                        hidden: Hidden_,
16280
                                        text: rec.HeaderTitle,
16281
                                        dataIndex: rec.FieldName,
16282
                                        valueField : valueField,
16283
                                        displayField : displayValue,
16284
                                        store : 'store_' + me.tableName + rec.FieldName,
16285
                                        tpl: Ext.create('Ext.XTemplate',
16286
                                            '<ul class="x-list-plain"><tpl for=".">',
16287
                                            '<li role="option" class="x-boundlist-item">{' + AdditionaldisplayValue + '} - {' + displayValue + '}</li>',
16288
                                            '</tpl></ul>'),
16289
                                        displayTpl: Ext.create('Ext.XTemplate',
16290
                                            '<tpl for=".">',
16291
                                            '{' + AdditionaldisplayValue + '} - {' + displayValue + '}',
16292
                                            '</tpl>'),
16293
                                        editor: {
16294
                                            allowBlank: null_,
16295
                                            xtype: 'combobox',
16296
                                            readOnly: ReadOnly_,
16297
                                            id: rec.TableName + rec.FieldName,
16298
                                            nameTable: rec.TableName,
16299
                                            fieldGrid: rec.FieldName,
16300
                                            valueField: valueField,
16301
                                            displayField: displayValue,
16302
                                            store: 'store_' + me.tableName + rec.FieldName,
16303
                                            value: rec.DefaultValue,
16304
                                            tpl: Ext.create('Ext.XTemplate',
16305
                                                '<ul class="x-list-plain"><tpl for=".">',
16306
                                                '<li role="option" class="x-boundlist-item">{' + AdditionaldisplayValue + '} - {' + displayValue + '}</li>',
16307
                                                '</tpl></ul>'),
16308
                                            displayTpl: Ext.create('Ext.XTemplate',
16309
                                                '<tpl for=".">',
16310
                                                '{' + AdditionaldisplayValue + '} - {' + displayValue + '}',
16311
                                                '</tpl>')
16312
                                        },
16313
                                        renderer: function (value) {
16314
                                            var store = Ext.data.StoreManager.lookup('store_' + me.tableName + rec.FieldName);
16315
                                            var index = store.find(valueField, value);
16316
                                            var val = "";
16317
                                            if (index != -1) {
16318
                                                var rc = store.getAt(index);
16319
                                                //val = rc.get(displayValue);
16320
                                                val = rc.get(AdditionaldisplayValue) + ' - ' + rc.get(displayValue);
16321
                                            } else {
16322
                                                val = value;
16323
                                            }
16324
                                            return val;
16325
                                        },
16326
                                        filter: {
16327
                                            type: 'list',
16328
                                            itemDefaults: {
16329
                                                emptyText: 'Search for...'
16330
                                            }
16331
                                        }
16332
                                    });
16333
                                } else if (rec.SearchType == '2') {
16334
                                    var triger = (rec.TriggerCombo).split('$');
16335
                                    var targetField_ = triger[0];
16336
                                    var fieldValue_ = triger[1];
16337
                                    cols.push({
16338
                                        text: rec.HeaderTitle,
16339
                                        hidden: Hidden_,
16340
                                        dataIndex: rec.FieldName,
16341
                                        filter: {
16342
                                            itemDefaults: {
16343
                                                emptyText: 'Search for...'
16344
                                            }
16345
                                        },
16346
                                        editor: {
16347
                                            allowBlank: null_,
16348
                                            xtype: 'minovalookupgrid',
16349
                                            readOnly: ReadOnly_,
16350
                                            isGrid: true,
16351
                                            fieldTarget: targetField_,
16352
                                            fieldValue: fieldValue_,
16353
                                            isGrid: true,
16354
                                            id: tableName + rec.FieldName,
16355
                                            tableName: rec.TableRef, //name tabel yang jadi ref-nya
16356
                                            triggerCls: 'x-form-search-trigger',
16357
                                            vtype: 'alphanum', // disable space
16358
                                            nameTable: rec.TableName,
16359
                                            fieldGrid: rec.FieldName,
16360
                                            listeners: {
16361
                                                change: function (val) {
16362
                                                    var custumFunc = rec.SelectFunction;
16363
                                                    if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
16364
                                                        Ext.Ajax.request({
16365
                                                            async: false,
16366
                                                            method: 'POST',
16367
                                                            url: '/UserControl/GetStore',
16368
                                                            params: {
16369
                                                                tableName: 'PCMFUNC',
16370
                                                                param: 'FuncName[equal]' + rec.custumFunc + ',Active[=]1'
16371
                                                            },
16372
                                                            success: function (response) {
16373
                                                                var results = Ext.decode(response.responseText);
16374
                                                                data_ = results.data[0];
16375
                                                                if (data_ != undefined) {
16376
                                                                    custumFunc = data_.FunctionCode;
16377
                                                                }
16378
                                                            }
16379
                                                        });
16380
                                                    }
16381
                                                    if (custumFunc) {
16382
                                                        eval(custumFunc)
16383
                                                    }
16384
                                                }
16385
                                            }
16386
                                        }
16387
                                    });
16388
                                } else if (rec.SearchType == '3') {
16389
                                    cols.push({
16390
                                        text: rec.HeaderTitle,
16391
                                        hidden: Hidden_,
16392
                                        dataIndex: rec.FieldName,
16393
                                        filter: {
16394
                                            itemDefaults: {
16395
                                                emptyText: 'Search for...'
16396
                                            }
16397
                                        },
16398
                                        editor: {
16399
                                            allowBlank: null_,
16400
                                            // xtype: 'minovalookuptreePopup',
16401
                                            xtype: 'MinovaLookupTree',
16402
                                            readOnly: ReadOnly_,
16403
                                            id: tableName + rec.FieldName,
16404
                                            tableName: rec.TableRef, //name tabel yang jadi ref-nya
16405
                                            triggerCls: 'x-form-search-trigger',
16406
                                            vtype: 'alphanum', // disable space
16407
                                            treeSructure: rec.SearchFunction, //'O-O-P',
16408
                                            objClassValue: rec.ParamCombo, //'O',
16409
                                            nameTable: rec.TableName,
16410
                                            fieldGrid: rec.FieldName,
16411
                                            listeners: {
16412
                                                change: function (val) {
16413
                                                    var custumFunc = rec.SelectFunction;
16414
                                                    if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
16415
                                                        Ext.Ajax.request({
16416
                                                            async: false,
16417
                                                            method: 'POST',
16418
                                                            url: '/UserControl/GetStore',
16419
                                                            params: {
16420
                                                                tableName: 'PCMFUNC',
16421
                                                                param: 'FuncName[equal]' + rec.custumFunc + ',Active[=]1'
16422
                                                            },
16423
                                                            success: function (response) {
16424
                                                                var results = Ext.decode(response.responseText);
16425
                                                                data_ = results.data[0];
16426
                                                                if (data_ != undefined) {
16427
                                                                    custumFunc = data_.FunctionCode;
16428
                                                                }
16429
                                                            }
16430
                                                        });
16431
                                                    }
16432
                                                    if (custumFunc) {
16433
                                                        eval(custumFunc)
16434
                                                    }
16435
                                                }
16436
                                            }
16437
                                        }
16438
                                    });
16439
                                } else if (rec.SearchType != '0' && rec.SearchType != '1' && rec.SearchType != '3' && (rec.FieldName == 'EmployeeID' || rec.FieldName == 'ApplicantID' || rec.FieldName == 'EmployeeIDFrom' || rec.FieldName == 'EmployeeIDTo') && isLookup != true) {
16440
                                    var triger = (rec.TriggerCombo).split('&');
16441
                                    var targetField_ = triger[0];
16442
                                    var fieldValue_ = triger[0];
16443
                                    cols.push({
16444
                                        text: rec.HeaderTitle,
16445
                                        hidden: Hidden_,
16446
                                        dataIndex: rec.FieldName,
16447
                                        filter: {
16448
                                            itemDefaults: {
16449
                                                emptyText: 'Search for...'
16450
                                            }
16451
                                        },
16452
                                        editor: {
16453
                                            allowBlank: null_,
16454
                                            xtype: 'lookupemployee',
16455
                                            readOnly: ReadOnly_,
16456
                                            isGrid: true,
16457
                                            fieldTarget: targetField_,
16458
                                            fieldValue: fieldValue_,
16459
                                            isGrid: true,
16460
                                            id: tableName + rec.FieldName,
16461
                                            tableName: rec.TableRef, //name tabel yang jadi ref-nya
16462
                                            triggerCls: 'x-form-search-trigger',
16463
                                            vtype: 'alphanum', // disable space
16464
                                            nameTable: rec.TableName,
16465
                                            fieldGrid: rec.FieldName,
16466
                                            listeners: {
16467
                                                change: function (val) {
16468
                                                    var custumFunc = rec.SelectFunction;
16469
                                                    if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
16470
                                                        Ext.Ajax.request({
16471
                                                            async: false,
16472
                                                            method: 'POST',
16473
                                                            url: '/UserControl/GetStore',
16474
                                                            params: {
16475
                                                                tableName: 'PCMFUNC',
16476
                                                                param: 'FuncName[equal]' + rec.custumFunc + ',Active[=]1'
16477
                                                            },
16478
                                                            success: function (response) {
16479
                                                                var results = Ext.decode(response.responseText);
16480
                                                                data_ = results.data[0];
16481
                                                                if (data_ != undefined) {
16482
                                                                    custumFunc = data_.FunctionCode;
16483
                                                                }
16484
                                                            }
16485
                                                        });
16486
                                                    }
16487
                                                    if (custumFunc) {
16488
                                                        eval(custumFunc)
16489
                                                    }
16490
                                                }
16491
                                            }
16492
                                        }
16493
                                    });
16494
                                } else if (rec.SearchType == '4' && isLookup != true) {
16495
                                    cols.push({
16496

    
16497
                                        text: rec.HeaderTitle,
16498
                                        hidden: Hidden_,
16499
                                        dataIndex: rec.FieldName,
16500
                                        filter: {
16501
                                            itemDefaults: {
16502
                                                emptyText: 'Search for...'
16503
                                            }
16504
                                        },
16505
                                        editor: {
16506
                                            allowBlank: null_,
16507
                                            xtype: 'lookupemployee',
16508
                                            readOnly: ReadOnly_,
16509
                                            isGrid: true,
16510
                                            fieldTarget: targetField_,
16511
                                            fieldValue: fieldValue_,
16512
                                            isGrid: true,
16513
                                            id: tableName + rec.FieldName,
16514
                                            tableName: rec.TableRef, //name tabel yang jadi ref-nya
16515
                                            triggerCls: 'x-form-search-trigger',
16516
                                            vtype: 'alphanum', // disable space
16517
                                            nameTable: rec.TableName,
16518
                                            fieldGrid: rec.FieldName,
16519
                                            listeners: {
16520
                                                change: function (val) {
16521
                                                    var custumFunc = rec.SelectFunction;
16522
                                                    if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
16523
                                                        Ext.Ajax.request({
16524
                                                            async: false,
16525
                                                            method: 'POST',
16526
                                                            url: '/UserControl/GetStore',
16527
                                                            params: {
16528
                                                                tableName: 'PCMFUNC',
16529
                                                                param: 'FuncName[equal]' + rec.custumFunc + ',Active[=]1'
16530
                                                            },
16531
                                                            success: function (response) {
16532
                                                                var results = Ext.decode(response.responseText);
16533
                                                                data_ = results.data[0];
16534
                                                                if (data_ != undefined) {
16535
                                                                    custumFunc = data_.FunctionCode;
16536
                                                                }
16537
                                                            }
16538
                                                        });
16539
                                                    }
16540
                                                    if (custumFunc) {
16541
                                                        eval(custumFunc)
16542
                                                    }
16543
                                                }
16544
                                            }
16545
                                        }
16546
                                    });
16547
                                } else {
16548
                                    cols.push({
16549
                                        text: rec.HeaderTitle,
16550
                                        hidden: Hidden_,
16551
                                        dataIndex: rec.FieldName,
16552
                                        filter: {
16553
                                            itemDefaults: {
16554
                                                emptyText: 'Search for...'
16555
                                            }
16556
                                        },
16557
                                        editor: {
16558
                                            allowBlank: null_,
16559
                                            xtype: 'textfield',
16560
                                            readOnly: ReadOnly_,
16561
                                            id: tableName + rec.FieldName,
16562
                                            nameTable: rec.TableName,
16563
                                            fieldGrid: rec.FieldName,
16564
                                            listeners: {
16565
                                                change: function (val) {
16566
                                                    var custumFunc = null;
16567
                                                    Ext.Ajax.request({
16568
                                                        async: false,
16569
                                                        method: 'POST',
16570
                                                        url: '/UserControl/GetStore',
16571
                                                        params: {
16572
                                                            tableName: 'SDATATABLEFIELD',
16573
                                                            param: 'FieldName[equal]' + rec.FieldName + ',TableName[equal]' + me.tableName
16574
                                                        },
16575
                                                        success: function (response) {
16576
                                                            var results = Ext.decode(response.responseText);
16577
                                                            data_ = results.data[0];
16578
                                                            if (data_ != undefined) {
16579
                                                                custumFunc = data_.SelectFunction;
16580
                                                                //console.log(data_)
16581
                                                            }
16582
                                                        }
16583
                                                    });
16584
                                                    if (custumFunc) {
16585
                                                        eval(custumFunc)
16586
                                                    }
16587
                                                }
16588
                                            }
16589
                                        }
16590
                                    });
16591
                                }
16592
                                break
16593
                        }
16594
                    }
16595
                } else {
16596
                    cols.push({
16597
                        text: rec.HeaderTitle,
16598
                        hidden: Hidden_,
16599
                        dataIndex: rec.FieldName,
16600
                        hidden: true,
16601
                        editor: {
16602
                            allowBlank: true,
16603
                            xtype: 'textfield',
16604
                            readOnly: ReadOnly_,
16605
                            id: tableName + rec.FieldName,
16606
                            nameTable: rec.TableName,
16607
                            fieldGrid: rec.FieldName,
16608
                        },
16609
                        filter: {
16610
                            itemDefaults: {
16611
                                emptyText: 'Search for...'
16612
                            }
16613
                        }
16614
                    });
16615
                }
16616
            })
16617
        }
16618
        addData = addData + "}";
16619

    
16620
        cols.push({
16621
            text: 'Action',
16622
            width: 100,
16623
            xtype: 'actioncolumn',
16624
            tooltip: 'View Data',
16625
            name: 'Action',
16626
            itemId: 'Action',
16627
            align: 'center',
16628
            iconCls: 'fa-edit',
16629
            renderer: function (value, metadata, record) {
16630
                metadata.tdStyle = 'font-family: FontAwesome'
16631
            },
16632
            handler: function (grid, rowIndex, colIndex, actionItem, event, record, row) {
16633
                var main_ = Ext.ComponentQuery.query('[name=grid' + me.tableName + ']')[0];
16634
                this.fireEvent("onEditClick");
16635
            }
16636
        });
16637

    
16638
        Ext.applyIf(me, {
16639

    
16640
            items: [{
16641
                xtype: 'treepanel',
16642
                id: gridName,
16643
                name: gridName,
16644
                height: height,
16645
                width: 'fit',
16646
                autoHeight: true,
16647
                //store: 'gridStore',
16648
                autoLoad: false,
16649
                autoScroll: true,
16650
                useArrows: true,
16651
                animate: false,
16652
                rootVisible: false,
16653
                plugins: [
16654
                    Ext.create('Ext.grid.plugin.CellEditing', {
16655
                        clicksToEdit: 2
16656
                    })
16657
                ],
16658
                root: {
16659
                    expanded: true,
16660
                    nodeType: 'async',
16661
                    ext: 'Favorites',
16662
                    id: 'null'
16663
                },
16664
                columns: cols,
16665
                //selType: 'rowmodel',
16666
            }
16667
            ]
16668

    
16669
        });
16670

    
16671
        me.callParent(arguments);
16672
    }
16673
});
16674
/*Add by Taufan ( Tab List MasterData For ERP )*/
16675
Ext.define('MinovaUtil.MinovaES.MinovaTabListMasterData', {
16676
    extend: 'Ext.tab.Panel',
16677
    alias: ['widget.masterdatatablist'],
16678
    moduleType: undefined,
16679
    tablenameheader: undefined,
16680
    langId: undefined,
16681
    param: undefined,
16682
    layout: 'fit',
16683
    name: 'panelTab',
16684
    id: 'mainTab',    
16685
    initComponent: function () {
16686
        var me = this;
16687
        var hasil = null;
16688
        var action = "0";
16689
        var _items = [];
16690
        var act = getParam("action");
16691
        if (act == 'add') {
16692
            action = '0';
16693
        }
16694
        if (act == 'edit') {
16695
            action = '1';
16696
        }
16697
        if (act == 'view') {
16698
            action = '1';
16699
        }
16700
        if (act == 'copy') {
16701
            action = '0';
16702
        }
16703
        Ext.Ajax.request({
16704
            async: false,
16705
            method: 'POST',
16706
            url: '/UserControl/GetStore',
16707
            params: {
16708
                tableName: 'PCMEPMDLIST',
16709
                param: 'ModuleType[=]' + me.moduleType + ',Language[=]' + me.langId
16710
            },
16711
            success: function (response) {
16712
                var results = Ext.decode(response.responseText);
16713
                hasil = results.data;                
16714
            }
16715
        });
16716
        hasil = hasil.sort(MinovaUtil.SortBy("Sequence"));
16717
        if (hasil.length > 0) {
16718
            Ext.each(hasil, function (rec) {
16719
                if (rec.LayoutType == "L004") { // L004=Custom
16720
                    var pnl = Ext.create(rec.CustomLayout, {
16721
                        title: rec.LabelName,
16722
                        tableName: rec.TableName,
16723
                        height: 450,
16724
                        name: 'panelTab' + rec.TableName,
16725
                        tbl: rec.TableName,
16726
                        layoutType: rec.LayoutType
16727
                    });
16728
                    _items.push(pnl)
16729
                } else if (rec.LayoutType == "L002" || rec.LayoutType == "L003") {
16730
                    _items.push({
16731
                        xtype: 'panel',
16732
                        title: rec.LabelName,
16733
                        name: 'panelTab' + rec.TableName,
16734
                        tbl: rec.TableName,
16735
                        layoutType: rec.LayoutType,
16736
                        items: [{
16737
                            xtype: 'minovagrid1',
16738
                            height: 450,
16739
                            tableName: rec.TableName,
16740
                            storename: 'store' + rec.TableName,
16741
                            pagesize: 25,
16742
                            name: 'GRID' + rec.TableName,
16743
                            margin: '0 0 10 0',
16744
                            autoLoad: false,
16745
                            tbar: [{
16746
                                xtype: 'button',
16747
                                text: 'Action',
16748
                                name: 'actionGrid' + rec.TableName,
16749
                                menu: [{
16750
                                    text: 'Add',
16751
                                    name: 'add' + rec.TableName,
16752
                                    tbl: rec.TableName,
16753
                                    style: 'font-family: FontAwesome',
16754
                                    iconCls: 'fa-plus-circle',
16755
                                    handler: function () {
16756
                                        var frmDisplay = Ext.ComponentQuery.query('[name=DISPLAY' + rec.TableName + ']')[0];
16757
                                        var frmForm = Ext.ComponentQuery.query('[name=FORM' + rec.TableName + ']')[0];
16758
                                        var grdPanel = Ext.ComponentQuery.query('[name=GRID' + rec.TableName + ']')[0];
16759
                                        var keyField = getParam("KeyID");
16760
                                        var keyValue = getParam("KeyValue");
16761
                                        frmDisplay.reset();
16762
                                        frmForm.reset();
16763
                                        var idseq = 0;
16764
                                        var params = {
16765
                                            apiController: 'api/Devt',
16766
                                            methodName: 'GetLastSeqID',
16767
                                            parameter: 'tableName=' + rec.TableName + '&keyField=' + keyField + '&keyValue=' + keyValue
16768
                                        };
16769
                                        MinovaAjaxPost('/ApiService/Api/', params, function (xhr) {
16770
                                            var result = Ext.decode(xhr.responseText);
16771
                                            var r = Ext.decode(result.data);
16772
                                            idseq = r.data + 1;
16773
                                            frmForm.getForm().findField(keyField).setValue(keyValue);
16774
                                            frmForm.getForm().findField("SeqID").setValue(idseq);
16775
                                        });
16776
                                        frmDisplay.setHidden(true);
16777
                                        frmForm.setHidden(false);
16778
                                        grdPanel.setHidden(true);
16779
                                        action = "0";
16780
                                    }
16781
                                }, {
16782
                                    text: 'Copy',
16783
                                    name: 'copy' + rec.TableName,
16784
                                    tbl: rec.TableName,
16785
                                    iconCls: 'fa-copy',
16786
                                    style: 'font-family: FontAwesome',
16787
                                    handler: function () {
16788
                                        var frmDisplay = Ext.ComponentQuery.query('[name=DISPLAY' + rec.TableName + ']')[0];
16789
                                        var frmForm = Ext.ComponentQuery.query('[name=FORM' + rec.TableName + ']')[0];
16790
                                        var grdPanel = Ext.ComponentQuery.query('[name=GRID' + rec.TableName + ']')[0];
16791
                                        var dtrec = grdPanel.getView().getSelectionModel().getSelection()[0];
16792
                                        var keyField = getParam("KeyID");
16793
                                        if (dtrec) {
16794
                                            frmDisplay.reset();
16795
                                            frmForm.reset();
16796
                                            frmForm.getForm().setValues(dtrec.data);
16797
                                            frmDisplay.setHidden(true);
16798
                                            frmForm.setHidden(false);
16799
                                            grdPanel.setHidden(true);
16800
                                            action = "0";
16801
                                            frmForm.getForm().findField(keyField).setValue("");
16802
                                        }
16803
                                    }
16804
                                }, {
16805
                                    text: 'Edit',
16806
                                    name: 'edit' + rec.TableName,
16807
                                    tbl: rec.TableName,
16808
                                    iconCls: 'fa-edit',
16809
                                    style: 'font-family: FontAwesome',
16810
                                    handler: function () {
16811
                                        var frmDisplay = Ext.ComponentQuery.query('[name=DISPLAY' + rec.TableName + ']')[0];
16812
                                        var frmForm = Ext.ComponentQuery.query('[name=FORM' + rec.TableName + ']')[0];
16813
                                        var grdPanel = Ext.ComponentQuery.query('[name=GRID' + rec.TableName + ']')[0];
16814
                                        var dtrec = grdPanel.getView().getSelectionModel().getSelection()[0];
16815
                                        if (dtrec) {
16816
                                            frmDisplay.reset();
16817
                                            frmForm.reset();
16818
                                            frmForm.getForm().setValues(dtrec.data);
16819
                                            frmDisplay.setHidden(true);
16820
                                            frmForm.setHidden(false);
16821
                                            grdPanel.setHidden(true);
16822
                                            action = "1";
16823
                                        }
16824
                                    }
16825
                                }
16826
                                ]
16827
                            }, {
16828
                                xtype: 'tbfill'
16829
                            }, {
16830
                                text: 'Clear Filters',
16831
                                tooltip: 'Clear all filters',
16832
                                name: 'clearbtn',
16833
                                handler: function () {}
16834
                            }
16835
                            ],
16836
                            dockedItems: [{
16837
                                xtype: 'pagingtoolbar',
16838
                                store: 'store' + rec.TableName,
16839
                                dock: 'bottom',
16840
                                pageSize: me.pagesize,
16841
                                displayInfo: true
16842
                            }
16843
                            ],
16844
                            listeners: {
16845
                                'itemdblclick': function (me, record, item, index, e, eOpts) {
16846
                                    var frmDisplay = Ext.ComponentQuery.query('[name=DISPLAY' + rec.TableName + ']')[0];
16847
                                    var frmForm = Ext.ComponentQuery.query('[name=FORM' + rec.TableName + ']')[0];
16848
                                    var grdPanel = Ext.ComponentQuery.query('[name=GRID' + rec.TableName + ']')[0];
16849
                                    frmDisplay.reset();
16850
                                    frmForm.reset();
16851
                                    frmDisplay.getForm().setValues(record.data);
16852
                                    frmForm.getForm().setValues(record.data);
16853
                                    frmDisplay.setHidden(false);
16854
                                    frmForm.setHidden(true);
16855
                                    grdPanel.setHidden(true);
16856
                                    action = "1";
16857
                                }
16858
                            }
16859
                        }, {
16860
                            xtype: 'minovaform',
16861
                            name: 'DISPLAY' + rec.TableName,
16862
                            id: 'DISPLAY' + rec.TableName,
16863
                            itemId: 'DISPLAY' + rec.TableName,
16864
                            tableName: rec.TableName,
16865
                            isDisplay: true,
16866
                            hidden: true,
16867
                            buttons: [{
16868
                                text: 'Edit',
16869
                                name: 'editDISPLAY' + rec.TableName,
16870
                                iconCls: 'fa-edit',
16871
                                style: 'font-family: FontAwesome',
16872
                                handler: function () {
16873
                                    var frmDisplay = Ext.ComponentQuery.query('[name=DISPLAY' + rec.TableName + ']')[0];
16874
                                    var frmForm = Ext.ComponentQuery.query('[name=FORM' + rec.TableName + ']')[0];
16875
                                    var grdPanel = Ext.ComponentQuery.query('[name=GRID' + rec.TableName + ']')[0];
16876
                                    frmDisplay.setHidden(true);
16877
                                    frmForm.setHidden(false);
16878
                                    grdPanel.setHidden(true);
16879
                                }
16880
                            }, {
16881
                                text: 'Cancel',
16882
                                name: 'cancelDISPLAY' + rec.TableName,
16883
                                iconCls: 'fa-reply',
16884
                                style: 'font-family: FontAwesome',
16885
                                handler: function () {
16886
                                    var frmDisplay = Ext.ComponentQuery.query('[name=DISPLAY' + rec.TableName + ']')[0];
16887
                                    var frmForm = Ext.ComponentQuery.query('[name=FORM' + rec.TableName + ']')[0];
16888
                                    var grdPanel = Ext.ComponentQuery.query('[name=GRID' + rec.TableName + ']')[0];
16889
                                    frmDisplay.setHidden(true);
16890
                                    frmForm.setHidden(true);
16891
                                    grdPanel.setHidden(false);
16892
                                    grdPanel.getStore().reload();
16893
                                }
16894
                            }
16895
                            ]
16896
                        }, {
16897
                            xtype: 'minovaform',
16898
                            name: 'FORM' + rec.TableName,
16899
                            id: 'FORM' + rec.TableName,
16900
                            itemId: 'FORM' + rec.TableName,
16901
                            tableName: rec.TableName,
16902
                            isDisplay: false,
16903
                            hidden: true,
16904
                            buttons: [{
16905
                                text: 'Save',
16906
                                name: 'saveFORM' + rec.TableName,
16907
                                iconCls: 'fa-save',
16908
                                style: 'font-family: FontAwesome',
16909
                                handler: function () {
16910
                                    var frmDisplay = Ext.ComponentQuery.query('[name=DISPLAY' + rec.TableName + ']')[0];
16911
                                    var frmForm = Ext.ComponentQuery.query('[name=FORM' + rec.TableName + ']')[0];
16912
                                    var grdPanel = Ext.ComponentQuery.query('[name=GRID' + rec.TableName + ']')[0];
16913
                                    var frm = frmForm.getForm();
16914
                                    console.log(frmForm);
16915
                                    if (frm.isValid()) {
16916
                                        var keyField = getParam("KeyID");
16917
                                        var table = rec.TableName;
16918
                                        var data = Ext.encode(frmForm.getValues());
16919
                                        var token = MinovaUtil.SESSIONS.Token;
16920
                                        var params = {
16921
                                            apiController: 'api/Devt',
16922
                                            methodName: 'SaveTableMaster',
16923
                                            parameter: 'tableName=' + table + '&data=' + data + '&action=' + action + '&token=' + token
16924
                                        };
16925
                                        MinovaAjaxPost('/ApiService/Api/', params, function (xhr) {
16926
                                            var result = Ext.decode(xhr.responseText);
16927
                                            var r = Ext.decode(result.data);
16928
                                            if (r.success) {
16929
                                                frmDisplay.setHidden(true);
16930
                                                frmForm.setHidden(true);
16931
                                                grdPanel.setHidden(false);
16932
                                                grdPanel.getStore().reload();
16933
                                                MinovaMessage('Not Null', '000006', '', 'S');
16934
                                            } else {
16935
                                                MinovaMessage(' Not Null ', ' 000005 ', r.message.text, 'E');
16936
                                            }
16937
                                        });
16938
                                    }
16939
                                }
16940
                            }, {
16941
                                text: 'Delete',
16942
                                name: 'deleteFORM' + rec.TableName,
16943
                                iconCls: 'fa-trash-o',
16944
                                style: 'font-family: FontAwesome ',                                
16945
                                handler: function () {
16946
                                    alert('Delete Function');
16947
                                    MinovaMessage(' Message ', ' 000007 ', ' ', 'C', function (respone) {
16948
                                        if (respone == "yes") {
16949
                                            var frmDisplay = Ext.ComponentQuery.query('[name=DISPLAY' + rec.TableName + ']')[0];
16950
                                            var frmForm = Ext.ComponentQuery.query('[name=FORM' + rec.TableName + ']')[0];
16951
                                            var grdPanel = Ext.ComponentQuery.query('[name=GRID' + rec.TableName + ']')[0];
16952
                                            var frm = frmForm.getForm();
16953
                                            if (frm.isValid()) {
16954
                                                var keyField = getParam("KeyID");
16955
                                                var table = rec.TableName;
16956
                                                var data = Ext.encode(frmForm.getValues());
16957
                                                var token = MinovaUtil.SESSIONS.Token;
16958
                                                action = "2";
16959
                                                var params = {
16960
                                                    apiController: 'api/Devt',
16961
                                                    methodName: 'SaveTableMaster',
16962
                                                    parameter: 'tableName=' + table + '&data=' + data + '&action=' + action + '&token=' + token
16963
                                                };
16964
                                                MinovaAjaxPost('/ApiService/Api/', params, function (xhr) {
16965
                                                    var result = Ext.decode(xhr.responseText);
16966
                                                    var r = Ext.decode(result.data);
16967
                                                    if (r.success) {
16968
                                                        frmDisplay.setHidden(true);
16969
                                                        frmForm.setHidden(true);
16970
                                                        grdPanel.setHidden(false);
16971
                                                        grdPanel.getStore().reload();
16972
                                                        MinovaMessage('Not Null', '000006', '', 'S');
16973
                                                    } else {
16974
                                                        MinovaMessage(' Not Null ', ' 000005 ', r.message.text, 'E');
16975
                                                    }
16976
                                                });
16977
                                            }
16978
                                        }
16979
                                    });
16980
                                }
16981
                            }, {
16982
                                text: 'Cancel',
16983
                                name: 'cancelFORM' + rec.TableName,
16984
                                iconCls: 'fa-reply',
16985
                                style: 'font-family: FontAwesome',
16986
                                handler: function () {
16987
                                    MinovaMessage('Message', '000011', '', 'C', function (respone) {
16988
                                        if (respone == "yes") {
16989
                                            var frmDisplay = Ext.ComponentQuery.query('[name=DISPLAY' + rec.TableName + ']')[0];
16990
                                            var frmForm = Ext.ComponentQuery.query('[name=FORM' + rec.TableName + ']')[0];
16991
                                            var grdPanel = Ext.ComponentQuery.query('[name=GRID' + rec.TableName + ']')[0];
16992
                                            frmDisplay.setHidden(true);
16993
                                            frmForm.setHidden(true);
16994
                                            grdPanel.setHidden(false);
16995
                                            grdPanel.getStore().reload();
16996
                                        }
16997
                                    });
16998
                                }
16999
                            }
17000
                            ]
17001
                        }
17002
                        ]
17003
                    });
17004
                } else if (rec.LayoutType == "L005") { // Grid View Only
17005
                    _items.push({
17006
                        xtype: 'panel',
17007
                        title: rec.LabelName,
17008
                        name: 'panelTab' + rec.TableName,
17009
                        tbl: rec.TableName,
17010
                        layoutType: rec.LayoutType,
17011
                        items: [{
17012
                            xtype: 'minovagrid1',
17013
                            height: 450,
17014
                            tableName: rec.TableName,
17015
                            storename: 'store' + rec.TableName,
17016
                            pagesize: 25,
17017
                            name: 'GRID' + rec.TableName,
17018
                            margin: '0 0 10 0',
17019
                            autoLoad: false,
17020
                            tbar: [{
17021
                                xtype: 'tbfill'
17022
                            }, {
17023
                                text: 'Clear Filters',
17024
                                tooltip: 'Clear all filters',
17025
                                name: 'clearbtn',
17026
                                handler: function () {}
17027
                            }
17028
                            ],
17029
                            dockedItems: [{
17030
                                xtype: 'pagingtoolbar',
17031
                                store: 'store' + rec.TableName,
17032
                                dock: 'bottom',
17033
                                pageSize: me.pagesize,
17034
                                displayInfo: true
17035
                            }
17036
                            ]
17037
                        }
17038
                        ]
17039
                    });
17040
                } else { // L001=Default Form Only
17041
                    _items.push({
17042
                        xtype: 'panel',
17043
                        title: rec.LabelName,
17044
                        name: 'panelTab' + rec.TableName,
17045
                        tbl: rec.TableName,
17046
                        layoutType: rec.LayoutType,
17047
                        items: [{
17048
                            xtype: 'minovaform',
17049
                            name: 'DISPLAY' + rec.TableName,
17050
                            id: 'DISPLAY' + rec.TableName,
17051
                            itemId: 'DISPLAY' + rec.TableName,
17052
                            tableName: rec.TableName,
17053
                            isDisplay: true,
17054
                            hidden: false,
17055
                            buttons: [{
17056
                                text: 'Edit',
17057
                                name: 'editDISPLAY' + rec.TableName,
17058
                                iconCls: 'fa-edit',
17059
                                style: 'font-family: FontAwesome',
17060
                                handler: function () {
17061
                                    var frmDisplay = Ext.ComponentQuery.query('[name=DISPLAY' + rec.TableName + ']')[0];
17062
                                    var frmForm = Ext.ComponentQuery.query('[name=FORM' + rec.TableName + ']')[0];
17063
                                    frmDisplay.setHidden(true);
17064
                                    frmForm.setHidden(false);
17065
                                    action = "1";
17066
                                }
17067
                            }, {
17068
                                text: 'Back',
17069
                                name: 'cancelDISPLAY' + rec.TableName,
17070
                                iconCls: 'fa-reply',
17071
                                style: 'font-family: FontAwesome',
17072
								handler: function () {
17073
									window.history.back();
17074
								},
17075
								hidden: false
17076
                            }
17077
                            ]
17078
                        }, {
17079
                            xtype: 'minovaform',
17080
                            name: 'FORM' + rec.TableName,
17081
                            id: 'FORM' + rec.TableName,
17082
                            itemId: 'FORM' + rec.TableName,
17083
                            tableName: rec.TableName,
17084
                            isDisplay: false,
17085
                            hidden: true,
17086
                            buttons: [{
17087
                                text: 'Save',
17088
                                name: 'saveDISPLAY' + rec.TableName,
17089
                                iconCls: 'fa-save',
17090
                                style: 'font-family: FontAwesome',
17091
                                handler: function () {
17092
                                    var frmDisplay = Ext.ComponentQuery.query('[name=DISPLAY' + rec.TableName + ']')[0];
17093
                                    var frmForm = Ext.ComponentQuery.query('[name=FORM' + rec.TableName + ']')[0];
17094
                                    var headerDisplay = Ext.ComponentQuery.query('[name=MainHeaderMDLogistic]')[0];
17095
                                    var frm = frmForm.getForm();
17096
                                    if (frm.isValid()) {
17097
                                        var keyField = getParam("KeyID");
17098
                                        var table = rec.TableName;
17099
                                        var data = Ext.encode(frmForm.getValues());
17100
                                        var token = MinovaUtil.SESSIONS.Token;
17101
                                        var params = {
17102
                                            apiController: 'api/Devt',
17103
                                            methodName: 'SaveTableMaster',
17104
                                            parameter: 'tableName=' + table + '&data=' + data + '&action=' + action + '&token=' + token
17105
                                        };
17106
                                        MinovaAjaxPost('/ApiService/Api/', params, function (xhr) {
17107
                                            var result = Ext.decode(xhr.responseText);
17108
                                            var r = Ext.decode(result.data);
17109
                                            if (r.success) {
17110
                                                headerDisplay.mask("Loading...");
17111
                                                var idNo = r.data;
17112
                                                frmForm.getForm().findField(keyField).setValue(idNo);
17113
                                                frmDisplay.getForm().setValues(frmForm.getValues());
17114
                                                headerDisplay.getForm().setValues(frmForm.getValues());
17115
                                                frmDisplay.setHidden(false);
17116
                                                frmForm.setHidden(true);
17117
                                                MinovaMessage('Not Null', '000006', '', 'S');
17118
                                                headerDisplay.unmask();
17119
                                            } else {
17120
                                                MinovaMessage(' Not Null ', ' 000005 ', r.message.text, 'E');
17121
                                            }
17122
                                        });
17123
                                    }
17124
                                }
17125
                            }, {
17126
                                text: 'Delete',
17127
                                name: 'deleteDISPLAY' + rec.TableName,
17128
                                iconCls: 'fa-trash-o',
17129
                                style: 'font-family: FontAwesome',
17130
                                handler: function () {                                    
17131
                                    MinovaMessage(' Message ', ' 000007 ', ' ', 'C', function (respone) {
17132
                                        if (respone == "yes") {
17133
                                            var frmDisplay = Ext.ComponentQuery.query('[name=DISPLAY' + rec.TableName + ']')[0];
17134
                                            var frmForm = Ext.ComponentQuery.query('[name=FORM' + rec.TableName + ']')[0];
17135
                                            var grdPanel = Ext.ComponentQuery.query('[name=GRID' + rec.TableName + ']')[0];
17136
                                            var frm = frmForm.getForm();
17137
                                            if (frm.isValid()) {
17138
                                                var keyField = getParam("KeyID");
17139
                                                var table = rec.TableName;
17140
                                                var data = Ext.encode(frmForm.getValues());
17141
                                                var token = MinovaUtil.SESSIONS.Token;
17142
                                                action = "2";
17143
                                                var params = {
17144
                                                    apiController: 'api/Devt',
17145
                                                    methodName: 'SaveTableMaster',
17146
                                                    parameter: 'tableName=' + table + '&data=' + data + '&action=' + action + '&token=' + token
17147
                                                };
17148
                                                MinovaAjaxPost('/ApiService/Api/', params, function (xhr) {
17149
                                                    var result = Ext.decode(xhr.responseText);
17150
                                                    var r = Ext.decode(result.data);
17151
                                                    if (r.success) {
17152
                                                        frmDisplay.setHidden(true);
17153
                                                        frmForm.setHidden(true);
17154
                                                        grdPanel.setHidden(false);
17155
                                                        grdPanel.getStore().reload();
17156
                                                        MinovaMessage('Not Null', '000006', '', 'S');
17157
                                                    } else {
17158
                                                        MinovaMessage(' Not Null ', ' 000005 ', r.message.text, 'E');
17159
                                                    }
17160
                                                });
17161
                                            }
17162
                                        }
17163
                                    });
17164
                                }
17165
                            }, {
17166
                                text: 'Cancel',
17167
                                name: 'cancelDISPLAY' + rec.TableName,
17168
                                iconCls: 'fa-reply',
17169
                                style: 'font-family: FontAwesome',
17170
                                handler: function () {
17171
                                    MinovaMessage('Message', '000011', '', 'C', function (respone) {
17172
                                        if (respone == "yes") {
17173
                                            var frmDisplay = Ext.ComponentQuery.query('[name=DISPLAY' + rec.TableName + ']')[0];
17174
                                            var frmForm = Ext.ComponentQuery.query('[name=FORM' + rec.TableName + ']')[0];
17175
                                            frmDisplay.setHidden(false);
17176
                                            frmForm.setHidden(true);
17177
                                        }
17178
                                    });
17179
                                }
17180
                            }
17181
                            ]
17182
                        }
17183
                        ]
17184
                    });
17185
                }
17186
            });
17187
        }
17188
        Ext.applyIf(me, {
17189
            items: _items
17190
        });
17191
        me.callParent(arguments);
17192
    }
17193
});
17194
/*Add by Taufan ( Tab List Doc Transaction For ERP )*/
17195
Ext.define('MinovaUtil.MinovaES.MinovaTabListDocTrans', {
17196
    extend: 'Ext.tab.Panel',
17197
    alias: ['widget.doctablist'],
17198
    transType: undefined,
17199
    docType: undefined,
17200
    docNo: undefined,
17201
    langId: undefined,
17202
    param: undefined,
17203
    layout: 'fit',
17204
    name: 'panelTab',
17205
    id: 'mainTab',
17206
    action: undefined,
17207
    initComponent: function () {
17208
        var me = this;
17209
        var documentType = me.docType;
17210
        var transactionType = me.transType;
17211
        var hasil = null;
17212
        var _items = [];
17213
        Ext.Ajax.request({
17214
            async: false,
17215
            method: 'POST',
17216
            url: '/UserControl/GetStore',
17217
            params: {
17218
                tableName: 'PCMBSTRANSLIST',
17219
                param: 'TransType[=]' + me.transType
17220
            },
17221
            success: function (response) {
17222
                var results = Ext.decode(response.responseText);
17223
                hasil = results.data;
17224
            }
17225
        });
17226
        hasil = hasil.sort(MinovaUtil.SortBy("Sequence"));
17227
        if (hasil.length > 0) {
17228
            Ext.each(hasil, function (rec) {
17229
                if (rec.LayoutType == "L004") { // L004=Custom
17230
                    var pnl = Ext.create(rec.CustomLayout, {
17231
                        title: rec.Title,
17232
                        tableName: rec.TableName,
17233
                        height: 400,
17234
                        name: 'panelTab' + rec.TableName,
17235
                        tbl: rec.TableName,
17236
                        layoutType: rec.LayoutType
17237
                    });
17238
                    _items.push(pnl)
17239
                } else if (rec.LayoutType == "L002" || rec.LayoutType == "L003") {
17240
                    _items.push({
17241
                        xtype: 'panel',
17242
                        title: rec.Title,
17243
                        name: 'panelTab' + rec.TableName,
17244
                        tbl: rec.TableName,
17245
                        layoutType: rec.LayoutType,
17246
                        items: [{
17247
                            xtype: 'docgrid',
17248
                            height: 400,
17249
                            tableName: rec.TableName,
17250
                            docType: me.docType,
17251
                            transType: me.transType,
17252
                            storename: 'store' + rec.TableName,
17253
                            pagesize: 25,
17254
                            name: 'GRID' + rec.TableName,
17255
                            margin: '0 0 10 0',
17256
                            autoLoad: false,
17257
                            tbar: [{
17258
                                xtype: 'button',
17259
                                text: 'Action',
17260
                                name: 'actionGrid' + rec.TableName,
17261
                                menu: [{
17262
                                    text: 'Add',
17263
                                    name: 'add' + rec.TableName,
17264
                                    tbl: rec.TableName,
17265
                                    style: 'font-family: FontAwesome',
17266
                                    iconCls: 'fa-plus-circle',
17267
                                    handler: function () {
17268
                                        var frmDisplay = Ext.ComponentQuery.query('[name=DISPLAY' + rec.TableName + ']')[0];
17269
                                        var frmForm = Ext.ComponentQuery.query('[name=FORM' + rec.TableName + ']')[0];
17270
                                        var grdPanel = Ext.ComponentQuery.query('[name=GRID' + rec.TableName + ']')[0];
17271
                                        frmDisplay.reset();
17272
                                        frmForm.reset();
17273
                                        frmDisplay.setHidden(true);
17274
                                        frmForm.setHidden(false);
17275
                                        grdPanel.setHidden(true);
17276
                                        action = "0";
17277
                                    }
17278
                                }, {
17279
                                    text: 'Delete',
17280
                                    name: 'delete' + rec.TableName,
17281
                                    tbl: rec.TableName,
17282
                                    iconCls: 'fa-trash-o',
17283
                                    style: 'font-family: FontAwesome',
17284
                                    handler: function () {
17285
                                        var me = this;
17286
                                        var store = Ext.StoreMgr.lookup('store' + rec.TableName);
17287
                                        var grdPanel = Ext.ComponentQuery.query('[name=GRID' + rec.TableName + ']')[0];
17288
                                        Ext.MessageBox.show({
17289
                                            title: 'Remove tab',
17290
                                            msg: "This will remove. Do you want to continue?",
17291
                                            buttons: Ext.MessageBox.YESNO,
17292
                                            fn: function (choice) {
17293
                                                console.log(choice);
17294
                                                if (choice === 'yes') {
17295
                                                    var selection = grdPanel.getView().getSelectionModel().getSelection()[0];
17296
                                                    if (selection) {
17297
                                                        store.remove(selection);
17298
                                                    }
17299
                                                }
17300
                                            }
17301
                                        });
17302
                                    }
17303
                                }
17304
                                ]
17305
                            }, {
17306
                                xtype: 'tbfill'
17307
                            }, {
17308
                                text: 'Clear Filters',
17309
                                tooltip: 'Clear all filters',
17310
                                name: 'clearbtn',
17311
                                handler: function () {}
17312
                            }
17313
                            ],
17314
                            dockedItems: [{
17315
                                xtype: 'pagingtoolbar',
17316
                                store: 'store' + rec.TableName,
17317
                                dock: 'bottom',
17318
                                pageSize: me.pagesize,
17319
                                displayInfo: true
17320
                            }
17321
                            ],
17322
                            listeners: {
17323
                                'itemdblclick': function (me, record, item, index, e, eOpts) {
17324
                                    var frmDisplay = Ext.ComponentQuery.query('[name=DISPLAY' + rec.TableName + ']')[0];
17325
                                    var frmForm = Ext.ComponentQuery.query('[name=FORM' + rec.TableName + ']')[0];
17326
                                    var grdPanel = Ext.ComponentQuery.query('[name=GRID' + rec.TableName + ']')[0];
17327
                                    frmDisplay.reset();
17328
                                    frmForm.reset();
17329
                                    frmDisplay.getForm().setValues(record.data);
17330
                                    frmForm.getForm().setValues(record.data);
17331
                                    frmDisplay.setHidden(false);
17332
                                    frmForm.setHidden(true);
17333
                                    grdPanel.setHidden(true);
17334
                                    action = "1";
17335
                                }
17336
                            }
17337
                        }, {
17338
                            xtype: 'minovadocform',
17339
                            name: 'DISPLAY' + rec.TableName,
17340
                            id: 'DISPLAY' + rec.TableName,
17341
                            itemId: 'DISPLAY' + rec.TableName,
17342
                            tableName: rec.TableName,
17343
                            docType: me.docType,
17344
                            transType: me.transType,
17345
                            isDisplay: true,
17346
                            hidden: true,
17347
                            buttons: [{
17348
                                text: 'Edit',
17349
                                name: 'editDISPLAY' + rec.TableName,
17350
                                handler: function () {
17351
                                    var frmDisplay = Ext.ComponentQuery.query('[name=DISPLAY' + rec.TableName + ']')[0];
17352
                                    var frmForm = Ext.ComponentQuery.query('[name=FORM' + rec.TableName + ']')[0];
17353
                                    var grdPanel = Ext.ComponentQuery.query('[name=GRID' + rec.TableName + ']')[0];
17354
                                    frmDisplay.setHidden(true);
17355
                                    frmForm.setHidden(false);
17356
                                    grdPanel.setHidden(true);
17357
                                }
17358
                            }, {
17359
                                text: 'Cancel',
17360
                                name: 'cancelDISPLAY' + rec.TableName,
17361
                                handler: function () {
17362
                                    var frmDisplay = Ext.ComponentQuery.query('[name=DISPLAY' + rec.TableName + ']')[0];
17363
                                    var frmForm = Ext.ComponentQuery.query('[name=FORM' + rec.TableName + ']')[0];
17364
                                    var grdPanel = Ext.ComponentQuery.query('[name=GRID' + rec.TableName + ']')[0];
17365
                                    frmDisplay.setHidden(true);
17366
                                    frmForm.setHidden(true);
17367
                                    grdPanel.setHidden(false);
17368
                                    grdPanel.getStore().reload();
17369
                                }
17370
                            }
17371
                            ]
17372
                        }, {
17373
                            xtype: 'minovadocform',
17374
                            name: 'FORM' + rec.TableName,
17375
                            id: 'FORM' + rec.TableName,
17376
                            itemId: 'FORM' + rec.TableName,
17377
                            tableName: rec.TableName,
17378
                            docType: me.docType,
17379
                            transType: me.transType,
17380
                            isDisplay: false,
17381
                            hidden: true,
17382
                            buttons: [{
17383
                                text: 'Submit',
17384
                                name: 'submitFORM' + rec.TableName,
17385
                                handler: function () {
17386
                                    var frmDisplay = Ext.ComponentQuery.query('[name=DISPLAY' + rec.TableName + ']')[0];
17387
                                    var frmForm = Ext.ComponentQuery.query('[name=FORM' + rec.TableName + ']')[0];
17388
                                    var grdPanel = Ext.ComponentQuery.query('[name=GRID' + rec.TableName + ']')[0];
17389
                                    var frm = frmForm.getForm();
17390
                                    if (frm.isValid()) {
17391
                                        var table = rec.TableName;
17392
                                        var data = frmForm.getValues();
17393
                                        var token = MinovaUtil.SESSIONS.Token;
17394
                                        var str = grdPanel.getStore();
17395
                                        var idx = str.getCount();
17396
                                        str.insert(idx, data);
17397
                                        frmDisplay.setHidden(true);
17398
                                        frmForm.setHidden(true);
17399
                                        grdPanel.setHidden(false);
17400
                                    }
17401
                                }
17402
                            }, {
17403
                                text: 'Cancel',
17404
                                name: 'cancelFORM' + rec.TableName,
17405
                                handler: function () {
17406
                                    MinovaMessage('Message', '000011', '', 'C', function (respone) {
17407
                                        if (respone == "yes") {
17408
                                            var frmDisplay = Ext.ComponentQuery.query('[name=DISPLAY' + rec.TableName + ']')[0];
17409
                                            var frmForm = Ext.ComponentQuery.query('[name=FORM' + rec.TableName + ']')[0];
17410
                                            var grdPanel = Ext.ComponentQuery.query('[name=GRID' + rec.TableName + ']')[0];
17411
                                            frmDisplay.setHidden(true);
17412
                                            frmForm.setHidden(true);
17413
                                            grdPanel.setHidden(false);
17414
                                        }
17415
                                    });
17416
                                }
17417
                            }
17418
                            ]
17419
                        }
17420
                        ]
17421
                    });
17422
                } else if (rec.LayoutType == "L005") { // Grid View Only
17423
                    _items.push({
17424
                        xtype: 'panel',
17425
                        title: rec.Title,
17426
                        name: 'panelTab' + rec.TableName,
17427
                        tbl: rec.TableName,
17428
                        layoutType: rec.LayoutType,
17429
                        items: [{
17430
                            xtype: 'docgrid',
17431
                            height: 400,
17432
                            tableName: rec.TableName,
17433
                            docType: me.docType,
17434
                            transType: me.transType,
17435
                            storename: 'store' + rec.TableName,
17436
                            pagesize: 25,
17437
                            name: 'GRID' + rec.TableName,
17438
                            margin: '0 0 10 0',
17439
                            autoLoad: false,
17440
                            tbar: [{
17441
                                xtype: 'tbfill'
17442
                            }, {
17443
                                text: 'Clear Filters',
17444
                                tooltip: 'Clear all filters',
17445
                                name: 'clearbtn',
17446
                                handler: function () {}
17447
                            }
17448
                            ],
17449
                            dockedItems: [{
17450
                                xtype: 'pagingtoolbar',
17451
                                store: 'store' + rec.TableName,
17452
                                dock: 'bottom',
17453
                                pageSize: me.pagesize,
17454
                                displayInfo: true
17455
                            }
17456
                            ]
17457
                        }
17458
                        ]
17459
                    });
17460
                } else if (rec.LayoutType == "L006") {
17461
                    _items.push({
17462
                        xtype: 'panel',
17463
                        title: rec.Title,
17464
                        name: 'panelTab' + rec.TableName,
17465
                        tbl: rec.TableName,
17466
                        layoutType: rec.LayoutType,
17467
                        items: [{
17468
                            xtype: 'docgridcelledit',
17469
                            name: 'CELLGRID' + rec.TableName,
17470
                            tableName: rec.TableName,
17471
                            docType: me.docType,
17472
                            transType: me.transType,
17473
                            docNo: me.docNo,
17474
                            height: 400,
17475
                            hideButton: false,
17476
                            margin: '0 0 10 0'
17477
                        }
17478
                        ]
17479
                    });
17480
                } else if (rec.LayoutType == "L007") {
17481
                    _items.push({
17482
                        xtype: 'panel',
17483
                        title: rec.Title,
17484
                        name: 'panelTab' + rec.TableName,
17485
                        tbl: rec.TableName,
17486
                        layoutType: rec.LayoutType,
17487
                        items: [{
17488
                            xtype: 'docgridcelleditsum',
17489
                            name: 'CELLGRID' + rec.TableName,
17490
                            tableName: rec.TableName,
17491
                            docType: me.docType,
17492
                            transType: me.transType,
17493
                            docNo: me.docNo,
17494
                            height: 400,
17495
                            hideButton: false,
17496
                            margin: '0 0 10 0'
17497
                        }, {
17498
                            xtype: 'summarydocform',
17499
                            name: 'SUM' + rec.TableName,
17500
                            id: 'SUM' + rec.TableName,
17501
                            itemId: 'SUM' + rec.TableName,
17502
                            tableName: rec.TableName,
17503
                            docType: me.docType,
17504
                            transType: me.transType,
17505
                        }
17506
                        ]
17507
                    });
17508
                } else { // L001=Default Form Only
17509
                    _items.push({
17510
                        xtype: 'panel',
17511
                        title: rec.LabelName,
17512
                        name: 'panelTab' + rec.TableName,
17513
                        tbl: rec.TableName,
17514
                        layoutType: rec.LayoutType,
17515
                        items: [{
17516
                            xtype: 'minovadocform',
17517
                            name: 'DISPLAY' + rec.TableName,
17518
                            id: 'DISPLAY' + rec.TableName,
17519
                            itemId: 'DISPLAY' + rec.TableName,
17520
                            tableName: rec.TableName,
17521
                            docType: me.docType,
17522
                            transType: me.transType,
17523
                            isDisplay: true,
17524
                            hidden: false,
17525
                            buttons: [{
17526
                                text: 'Edit',
17527
                                name: 'editDISPLAY' + rec.TableName,
17528
                                iconCls: 'fa-edit',
17529
                                style: 'font-family: FontAwesome',
17530
                                handler: function () {
17531
                                    var frmDisplay = Ext.ComponentQuery.query('[name=DISPLAY' + rec.TableName + ']')[0];
17532
                                    var frmForm = Ext.ComponentQuery.query('[name=FORM' + rec.TableName + ']')[0];
17533
                                    frmDisplay.setHidden(true);
17534
                                    frmForm.setHidden(false);
17535
                                    action = "1";
17536
                                }
17537
                            }, {
17538
                                text: 'Cancel',
17539
                                name: 'cancelDISPLAY' + rec.TableName,
17540
                                iconCls: 'fa-reply',
17541
                                style: 'font-family: FontAwesome',
17542
                                hidden: true
17543
                            }
17544
                            ]
17545
                        }, {
17546
                            xtype: 'minovadocform',
17547
                            name: 'FORM' + rec.TableName,
17548
                            id: 'FORM' + rec.TableName,
17549
                            itemId: 'FORM' + rec.TableName,
17550
                            tableName: rec.TableName,
17551
                            docType: me.docType,
17552
                            transType: me.transType,
17553
                            isDisplay: false,
17554
                            hidden: true,
17555
                            buttons: [{
17556
                                text: 'Save',
17557
                                name: 'saveDISPLAY' + rec.TableName,
17558
                                iconCls: 'fa-save',
17559
                                style: 'font-family: FontAwesome',
17560
                                handler: function () {
17561
                                    var frmDisplay = Ext.ComponentQuery.query('[name=DISPLAY' + rec.TableName + ']')[0];
17562
                                    var frmForm = Ext.ComponentQuery.query('[name=FORM' + rec.TableName + ']')[0];
17563
                                    var headerDisplay = Ext.ComponentQuery.query('[name=MainHeaderMDLogistic]')[0];
17564
                                    var frm = frmForm.getForm();
17565
                                    if (frm.isValid()) {
17566
                                        var table = rec.TableName;
17567
                                        var data = Ext.encode(frmForm.getValues());
17568
                                        var token = MinovaUtil.SESSIONS.Token;
17569
                                        var params = {
17570
                                            apiController: 'api/Devt',
17571
                                            methodName: 'SaveTableMaster',
17572
                                            parameter: 'tableName=' + table + '&data=' + data + '&action=' + action + '&token=' + token
17573
                                        };
17574
                                        MinovaAjaxPost('/ApiService/Api/', params, function (xhr) {
17575
                                            var result = Ext.decode(xhr.responseText);
17576
                                            var r = Ext.decode(result.data);
17577
                                            if (r.success) {
17578
                                                headerDisplay.mask("Loading...");
17579
                                                var idNo = r.data;
17580
                                                frmForm.getForm().findField("DocNo").setValue(idNo);
17581
                                                frmDisplay.getForm().setValues(frmForm.getValues());
17582
                                                headerDisplay.getForm().setValues(frmForm.getValues());
17583
                                                frmDisplay.setHidden(false);
17584
                                                frmForm.setHidden(true);
17585
                                                MinovaMessage('Not Null', '000006', '', 'S');
17586
                                                headerDisplay.unmask();
17587
                                            } else {
17588
                                                MinovaMessage(' Not Null ', ' 000005 ', r.message.text, 'E');
17589
                                            }
17590
                                        });
17591
                                    }
17592
                                }
17593
                            }, {
17594
                                text: 'Delete',
17595
                                name: 'deleteDISPLAY' + rec.TableName,
17596
                                iconCls: 'fa-trash-o',
17597
                                style: 'font-family: FontAwesome',
17598
                                handler: function () {}
17599
                            }, {
17600
                                text: 'Cancel',
17601
                                name: 'cancelDISPLAY' + rec.TableName,
17602
                                iconCls: 'fa-reply',
17603
                                style: 'font-family: FontAwesome',
17604
                                handler: function () {
17605
                                    MinovaMessage('Message', '000011', '', 'C', function (respone) {
17606
                                        if (respone == "yes") {
17607
                                            var frmDisplay = Ext.ComponentQuery.query('[name=DISPLAY' + rec.TableName + ']')[0];
17608
                                            var frmForm = Ext.ComponentQuery.query('[name=FORM' + rec.TableName + ']')[0];
17609
                                            frmDisplay.setHidden(false);
17610
                                            frmForm.setHidden(true);
17611
                                        }
17612
                                    });
17613
                                }
17614
                            }
17615
                            ]
17616
                        }
17617
                        ]
17618
                    });
17619
                }
17620
            });
17621
        }
17622
        Ext.applyIf(me, {
17623
            items: _items
17624
        });
17625
        me.callParent(arguments);
17626
    }
17627
});
17628
/*Add by Taufan ( Generate Doc Transaction Form For ERP )*/
17629
Ext.define('MinovaUtil.MinovaES.MinovaDocForm', {
17630
    extend: 'Ext.form.Panel',
17631
    alias: ['widget.MinovaDocForm', 'widget.minovadocform', 'widget.docform'],
17632
    formname: this.name,
17633
    tableName: undefined,
17634
    docType: undefined,
17635
    transType: undefined,
17636
    resizable: true,
17637
    border: false,
17638
    autoScroll: true,
17639
    isDisplay: undefined,
17640
    isLookup: undefined,
17641
    layout: 'column',
17642
    defaults: {
17643
        layout: 'form',
17644
        xtype: 'container',
17645
        defaultType: 'textfield',
17646
        style: 'width: 50%',
17647
    },
17648
    initComponent: function () {
17649
        var me = this;
17650
        var col1 = [];
17651
        var col2 = [];
17652
        var LangID = localStorage.LangId;
17653
        var parameter = "LangID='" + LangID + "',TableName='" + me.tableName + "',DocType='" + me.docType + "'";
17654
        var formname_ = me.name;
17655
        var nameTable_ = me.tableName;
17656
        Ext.Ajax.request({
17657
            async: false,
17658
            method: 'POST',
17659
            url: '/UserControl/GetStore',
17660
            params: {
17661
                tableName: 'PDSDOCFIELD',
17662
                param: parameter
17663
            },
17664
            success: function (response) {
17665
                var results = Ext.decode(response.responseText);
17666
                hasil = results.data;
17667
            }
17668
        });
17669
        if (hasil.length > 0) {
17670
            Ext.each(hasil, function (rec) {
17671
                var isnull = null;
17672
                if (rec.IsPrimaryKey == '1') {
17673
                    isnull = false;
17674
                }
17675
                if (rec.IsRequired == '1') {
17676
                    isnull = false;
17677
                } else {
17678
                    isnull = true;
17679
                }
17680
                var formfield = MinovaUtil.FieldGenerator.Form(me.name, rec, isnull, me.isDisplay, me.tableName, me.isLookup);
17681
                var descField = undefined;
17682
                if (rec.ColumnNo == 1) {
17683
                    col1.push(formfield);
17684
                    if (descField) {
17685
                        col1.push(descField)
17686
                    }
17687
                } else {
17688
                    col2.push(formfield);
17689
                    if (descField) {
17690
                        col2.push(descField)
17691
                    }
17692
                }
17693

    
17694
                if (rec.IsPrimaryKey == 1 && me.isLookup == undefined) {
17695
                    formfieldKey = new Ext.form.TextField({
17696
                        hidden: true,
17697
                        name: "Key_" + rec.FieldName,
17698
                    });
17699
                    col2.push(formfieldKey);
17700
                }
17701
            });
17702
        }
17703
        Ext.applyIf(me, {
17704
            items: [{
17705
                style: 'width: 50%',
17706
                items: col1
17707
            }, {
17708
                style: 'width: 50%',
17709
                items: col2
17710
            }
17711
            ]
17712
        });
17713
        this.callParent();
17714
    }
17715
});
17716
/*Add by Taufan ( Generate Doc Transaction Grid For ERP )*/
17717
Ext.define('MinovaUtil.MinovaES.MinovaDocGrid', {
17718
    extend: 'Ext.grid.Panel',
17719
    requires: ['Ext.grid.RowNumberer'],
17720
    alias: 'widget.docgrid',
17721
    alternateClassName: 'Ext.grid.MinovaGrid',
17722
    tableName: undefined,
17723
    docType: undefined,
17724
    transType: undefined,
17725
    isLookup: undefined,
17726
    param: undefined,
17727
    pagesize: undefined,
17728
    storename: undefined,
17729
    layoutType: undefined,
17730
    enableLocking: true,
17731
    autoLoad: undefined,
17732
    multiSelect: undefined,
17733
    getTableName: function () {
17734
        return this.tableName;
17735
    },
17736
    initComponent: function () {
17737
        var me = this;
17738
        var cols_ = [];
17739
        var fieldeditor = {};
17740
        var hasil = null;
17741
        var autoLoad = true;
17742
        var LangID = localStorage.LangId;
17743
        var fielGrid = 'rec.GridView == 1';
17744
        var locking = true;
17745
        var checkSelection = '';
17746
        var widthLock = 250;
17747
        if (me.multiSelect) {
17748
            locking = false;
17749
            checkSelection = 'checkboxmodel';
17750
            widthLock = 40;
17751
        }
17752
        if (me.autoLoad == false) {
17753
            autoLoad = false;
17754
        }
17755
        var parameter = "LangID='" + LangID + "',TableName='" + me.tableName + "',DocType='" + me.docType + "'";
17756
        Ext.Ajax.request({
17757
            async: false,
17758
            method: 'POST',
17759
            url: '/UserControl/GetStore',
17760
            params: {
17761
                tableName: 'PDSDOCFIELD',
17762
                param: parameter
17763
            },
17764
            success: function (response) {
17765
                var results = Ext.decode(response.responseText);
17766
                hasil = results.data;
17767
            }
17768
        });
17769
        if (hasil.length > 0) {
17770
            Ext.each(hasil, function (rec) {
17771
                var null_ = null;
17772
                if (rec.IsPrimaryKey == true) {
17773
                    null_ = false;
17774
                }
17775
                if (rec.IsRequired == true) {
17776
                    null_ = false;
17777
                } else {
17778
                    null_ = true;
17779
                }
17780
                if (rec.GridView == 1) {
17781
                    switch (rec.FormatRef) {
17782
                        case "action":
17783
                            cols_.push({
17784
                                text: rec.HeaderTitle,
17785
                                width: 100,
17786
                                xtype: 'actioncolumn',
17787
                                tooltip: 'View Data',
17788
                                name: rec.FieldName,
17789
                                itemId: me.tableName + rec.FieldName,
17790
                                align: 'center',
17791
                                iconCls: 'fa-edit',
17792
                                renderer: function (value, metadata, record) {
17793
                                    metadata.tdStyle = 'font-family: FontAwesome'
17794
                                },
17795
                                handler: function (grid, rowIndex, colIndex, actionItem, event, record, row) {
17796

    
17797
                                    this.fireEvent(me.tableName + rec.FieldName + "onActionClick", record);
17798
                                }
17799
                            });
17800
                            break
17801
                        case "file":
17802
                            cols_.push({
17803
                                xtype: 'minovapicturecolumn',
17804
                                text: rec.HeaderTitle,
17805
                                dataIndex: rec.FieldName,
17806
                                width: 100
17807
                            });
17808
                            break
17809
                        case "date":
17810
                            cols_.push({
17811
                                xtype: 'minovadatecolumn',
17812
                                text: rec.HeaderTitle,
17813
                                dataIndex: rec.FieldName,
17814
                                width: 100,
17815
                                filter: {
17816
                                    type: 'date',
17817
                                    itemDefaults: {
17818
                                        emptyText: 'Search for...'
17819
                                    }
17820
                                }
17821
                            });
17822
                            break
17823
                        case "amountencrypt":
17824
                            cols_.push({
17825
                                xtype: 'minovaamountcolumn',
17826
                                text: rec.HeaderTitle,
17827
                                dataIndex: rec.FieldName,
17828
                                align: 'right',
17829
                                width: 100,
17830
                                filter: {
17831
                                    type: 'string',
17832
                                    itemDefaults: {
17833
                                        emptyText: 'Search for...'
17834
                                    }
17835
                                }
17836
                            });
17837
                            break
17838
                        case "amount":
17839
                            cols_.push({
17840
                                xtype: 'minovacurrancycolumn',
17841
                                text: rec.HeaderTitle,
17842
                                dataIndex: rec.FieldName,
17843
                                align: 'right',
17844
                                width: 100,
17845
                                filter: {
17846
                                    type: 'number',
17847
                                    itemDefaults: {
17848
                                        emptyText: 'Search for...'
17849
                                    }
17850
                                }
17851
                            });
17852
                            break
17853
                        case "datetime":
17854
                            cols_.push({
17855
                                xtype: 'minovadatetimecolumn',
17856
                                text: rec.HeaderTitle,
17857
                                dataIndex: rec.FieldName,
17858
                                width: 140,
17859
                                filter: {
17860
                                    type: 'string',
17861
                                    itemDefaults: {
17862
                                        emptyText: 'Search for...'
17863
                                    }
17864
                                }
17865
                            });
17866
                            break
17867
                        default:
17868
                            if (rec.DataRef == 'CREATEBY' || rec.DataRef == 'CHANGEBY') {
17869
                                cols_.push({
17870
                                    text: rec.HeaderTitle,
17871
                                    dataIndex: rec.FieldName,
17872
                                    width: 100,
17873
                                    filter: {
17874
                                        type: 'string',
17875
                                        itemDefaults: {
17876
                                            emptyText: 'Search for...'
17877
                                        }
17878
                                    }
17879
                                });
17880
                            } else if (rec.TableRef != "") {
17881
                                if (rec.TableRef != null) {
17882
                                    var valueField = null;
17883
                                    var displayValue = null;
17884
                                    Ext.Ajax.request({
17885
                                        async: false,
17886
                                        method: 'POST',
17887
                                        url: '/UserControl/GetStore',
17888
                                        params: {
17889
                                            tableName: 'SDATATABLEFIELD',
17890
                                            param: 'TableName[equal]' + rec.TableRef
17891
                                        },
17892
                                        success: function (response) {
17893
                                            var results = Ext.decode(response.responseText);
17894
                                            data_ = results.data;
17895
                                            if (data_.length > 0) {
17896
                                                valueField_ = $.grep(data_, function (r) {
17897
                                                    return r.ValueField == '1'
17898
                                                });
17899
                                                valueField = valueField_[0].FieldName
17900
                                                displayValue_ = $.grep(data_, function (r) {
17901
                                                    return r.DisplayValue == '1'
17902
                                                });
17903
                                                displayValue = displayValue_[0].FieldName
17904
                                            } else {
17905
                                                MinovaMessage('Not Null', 'BSNULLCOMBO', rec.TableRef, 'E');
17906
                                            }
17907
                                        }
17908
                                    });
17909
                                    var store_ = Ext.StoreMgr.lookup('store_' + rec.FieldName);
17910
                                    var count_ = 0;
17911
                                    if (store_) {
17912
                                        count_ = store_.count();
17913
                                    }
17914
                                    if (count_ == 0) {
17915
                                        Ext.create('Ext.data.Store', {
17916
                                            storeId: 'store_' + rec.FieldName,
17917
                                            autoLoad: false,
17918
                                            proxy: {
17919
                                                method: 'POST',
17920
                                                type: 'ajax',
17921
                                                url: '/UserControl/GetStore',
17922
                                                extraParams: {
17923
                                                    tableName: rec.TableRef,
17924
                                                    param: rec.ParamCombo
17925
                                                },
17926
                                                reader: {
17927
                                                    type: 'json',
17928
                                                    root: 'data',
17929
                                                    totalProperty: 'data[0].TotalCount'
17930
                                                }
17931
                                            }
17932
                                        })
17933
                                    }
17934
                                    cols_.push({
17935
                                        xtype: 'minovacombocolumn',
17936
                                        text: rec.HeaderTitle,
17937
                                        dataIndex: rec.FieldName,
17938
                                        valueField: valueField,
17939
                                        displayField: displayValue,
17940
                                        store: 'store_' + rec.FieldName,
17941
                                        filter: {
17942
                                            type: 'list',
17943
                                            itemDefaults: {
17944
                                                emptyText: 'Search for...'
17945
                                            }
17946
                                        }
17947
                                    });
17948
                                }
17949
                            } else if (rec.FixedValue != "") {
17950
                                cols_.push({
17951
                                    xtype: 'minovacombocolumnfixvalue',
17952
                                    text: rec.HeaderTitle,
17953
                                    dataIndex: rec.FieldName,
17954
                                    fixedValue: rec.FixedValue,
17955
                                    filter: {
17956
                                        type: 'list',
17957
                                        itemDefaults: {
17958
                                            emptyText: 'Search for...'
17959
                                        }
17960
                                    }
17961
                                });
17962
                            } else {
17963
                                cols_.push({
17964
                                    text: rec.HeaderTitle,
17965
                                    dataIndex: rec.FieldName,
17966
                                    filter: {
17967
                                        itemDefaults: {
17968
                                            emptyText: 'Search for...'
17969
                                        }
17970
                                    }
17971
                                });
17972
                            }
17973
                            break
17974
                    }
17975
                } else {
17976
                    cols_.push({
17977
                        text: rec.HeaderTitle,
17978
                        dataIndex: rec.FieldName,
17979
                        hidden: true,
17980
                        filter: {
17981
                            itemDefaults: {
17982
                                emptyText: 'Search for...'
17983
                            }
17984
                        }
17985
                    });
17986
                }
17987

    
17988
            });
17989
        };
17990
        var param_ = me.param;
17991
        if (param_ == undefined) {
17992
            param_ = ''
17993
        }
17994
        var jsStoreGrid = new Ext.data.Store({
17995
            storeId: me.storename,
17996
            autoLoad: autoLoad,
17997
            pageSize: me.pagesize,
17998
            proxy: {
17999
                method: 'POST',
18000
                type: 'ajax',
18001
                url: '/UserControl/GetStorePagingAuth',
18002
                extraParams: {
18003
                    tableName: me.tableName,
18004
                    param: param_,
18005
                    menuId: MinovaUtil.GetMenuID()
18006
                },
18007
                reader: {
18008
                    type: 'json',
18009
                    root: 'data',
18010
                    totalProperty: 'totalRecords'
18011
                }
18012
            },
18013
        });
18014
        Ext.applyIf(me, {
18015
            autoScroll: true,
18016
            enableLocking: locking,
18017
            lockedGridConfig: {
18018
                header: false,
18019
                collapsible: true,
18020
                width: widthLock,
18021
                forceFit: locking,
18022
                listeners: {
18023
                    render: function (grid) {
18024
                        var pagingToolbar = grid.child('pagingtoolbar');
18025
                        if (pagingToolbar) {
18026
                            grid.remove(pagingToolbar, true);
18027
                        }
18028
                    }
18029
                }
18030
            },
18031
            listeners: {
18032
                viewready: function () {
18033
                    if (autoLoad == true) {
18034
                        this.getStore().loadPage(1);
18035
                    }
18036
                },
18037
                beforeedit: function () {
18038
                    return false;
18039
                }
18040
            },
18041
            lockedViewConfig: {
18042
                scroll: 'horizontal'
18043
            },
18044

    
18045
            //Add For Auto Size Coloum Mode
18046
            viewConfig: {
18047
                emptyText: 'No Data Display',
18048
                deferEmptyText: false,
18049
                listeners: {
18050
                    refresh: function (dataview) {
18051
                        Ext.each(dataview.panel.columns, function (column) {
18052
                            if (column.autoSizeColumn == false)
18053
                                column.autoSizeColumn = true;
18054
                                column.autoSize();
18055
                        })
18056
                    }
18057
                }
18058
            },
18059
            selModel: {},
18060
            selType: checkSelection,
18061
            columns: cols_,
18062
            store: jsStoreGrid,
18063
            plugins: [{
18064
                ptype: 'gridfilters'
18065
            }
18066
            ]
18067
        });
18068
        me.callParent(arguments);
18069
    }
18070
});
18071
/*Add by Taufan ( Generate Doc Transaction Cell Edit Grid  For ERP )*/
18072
Ext.define('MinovaUtil.MinovaES.MinovaDocGridCellEdit', {
18073
    extend: 'Ext.form.Panel',
18074
    alias: 'widget.docgridcelledit',
18075
    requires: [
18076
		'Ext.grid.plugin.CellEditing',
18077
		'Ext.grid.Panel'
18078
    ],
18079
    autoScroll: true,
18080
    anchor: '100%',
18081
    tableName: undefined,
18082
    docType: undefined,
18083
    transType: undefined,
18084
    docNo: undefined,
18085
    hideButton: undefined,
18086
    multiSelect: undefined,
18087
    initComponent: function () {
18088
        var me = this;
18089
        var isLookup = me.isLookup;
18090
        var hide_ = false;
18091
        var widthLock = 250;
18092
        var checkSelection = '';
18093

    
18094
        if (me.hideButton == true) {
18095
            hide_ = true;
18096
        }
18097
        if (me.multiSelect) {
18098
            locking = false;
18099
            checkSelection = 'checkboxmodel';
18100
            widthLock = 40;
18101
        }
18102
        var tableName = me.tableName;
18103
        var cols = [];
18104
        var fieldStore = [];
18105
        var _url = 'GetAllField';
18106
        var hasil = null;
18107
        var height = me.height;
18108
        var storeID = 'store' + me.tableName;
18109
        var gridName = 'grid' + me.name;
18110
        if (me.storeName) {
18111
            storeID = me.storeName;
18112
        }
18113
        var LangID = MinovaUtil.GetLangID();
18114
        var parameter = "LangID='" + LangID + "',TableName='" + me.tableName + "',DocType='" + me.docType + "'";
18115
        Ext.Ajax.request({
18116
            async: false,
18117
            method: 'POST',
18118
            url: '/UserControl/GetStore',
18119
            params: {
18120
                tableName: 'PDSDOCFIELD',
18121
                param: parameter
18122
            },
18123
            success: function (response) {
18124
                var results = Ext.decode(response.responseText);
18125
                hasil = results.data;
18126
            }
18127
        });
18128
        cols.push({
18129
            xtype: 'rownumberer'
18130
        });
18131
        var addData = '({';
18132
        if (hasil.length > 0) {
18133
            Ext.each(hasil, function (rec) {
18134
                fieldStore.push(rec.FieldName);
18135
                var defaultValue = rec.DefaultValue;
18136
                if (defaultValue.substring(0, 2).toLowerCase() == 'fn') {
18137
                    Ext.Ajax.request({
18138
                        async: false,
18139
                        method: 'POST',
18140
                        url: '/UserControl/GetStore',
18141
                        params: {
18142
                            tableName: 'PCMFUNC',
18143
                            param: 'FuncName[equal]' + rec.DefaultValue
18144
                        },
18145
                        success: function (response) {
18146
                            var results = Ext.decode(response.responseText);
18147
                            data_ = results.data;
18148
                            if (data_.length > 0) {
18149
                                defaultValue = eval(data_[0].FunctionCode);
18150
                            }
18151
                        }
18152
                    });
18153
                }
18154
                addData = addData + rec.FieldName + ":" + "'" + defaultValue + "',";
18155
                var null_ = null;
18156
                var ReadOnly_ = false;
18157
                if (rec.IsPrimaryKey == true) {
18158
                    null_ = false;
18159
                }
18160
                if (rec.IsRequired == true) {
18161
                    null_ = false;
18162
                } else {
18163
                    null_ = true;
18164
                }
18165
                var Hidden_ = false;
18166
                if (rec.ReadOnly == '1') {
18167
                    ReadOnly_ = true;
18168
                }
18169
                if (rec.IsHidden == '1' || rec.Sequence == '' || rec.Sequence == '0' || rec.ColumnNo == '' || rec.GridView == '') {
18170
                    Hidden_ = true;
18171
                    null_ = true;
18172
                }
18173
                if (rec.GridView == 1) {
18174
                    switch (rec.FormatRef) {
18175
                        case "date":
18176
                            cols.push({
18177
                                xtype: 'minovadatecolumn',
18178
                                hidden: Hidden_,
18179
                                text: rec.HeaderTitle,
18180
                                dataIndex: rec.FieldName,
18181
                                filter: {
18182
                                    itemDefaults: {
18183
                                        emptyText: 'Search for...'
18184
                                    }
18185
                                },
18186
                                editor: {
18187
                                    allowBlank: null_,
18188
                                    xtype: 'datefield',
18189
                                    hideMode: 'visibility',
18190
                                    readOnly: ReadOnly_,
18191
                                    id: tableName + rec.FieldName,
18192
                                    value: defaultValue
18193
                                }
18194
                            });
18195
                            break
18196
                        case "amount":
18197
                            cols.push({
18198
                                //xtype : 'minovacurrancycolumn',
18199
                                xtype: 'numbercolumn',
18200
                                text: rec.HeaderTitle,
18201
                                align: 'right',
18202
                                dataIndex: rec.FieldName,
18203
                                hidden: Hidden_,
18204
								minWidth: 150,
18205
                                filter: {
18206
                                    itemDefaults: {
18207
                                        emptyText: 'Search for...'
18208
                                    }
18209
                                },
18210
                                editor: {
18211
                                    allowBlank: null_,
18212
                                    xtype: 'textfield',
18213
                                    readOnly: ReadOnly_,
18214
                                    id: tableName + rec.FieldName,
18215
                                    nameTable: rec.TableName,
18216
                                    fieldGrid: rec.FieldName,
18217
                                    fieldStyle: 'text-align:right;',
18218
                                    vtype: 'validateMinovaNumber',
18219
                                    value: '0',
18220
                                    listeners: {
18221
                                        change: function (val, recs) {
18222
                                            var fvalue = val.getValue();
18223
                                            var custumFunc = rec.SelectFunction;
18224
                                            if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
18225
                                                Ext.Ajax.request({
18226
                                                    async: false,
18227
                                                    method: 'POST',
18228
                                                    url: '/UserControl/GetStore',
18229
                                                    params: {
18230
                                                        tableName: 'PCMFUNC',
18231
                                                        param: 'FuncName[equal]' + custumFunc + ',Active[=]1'
18232
                                                    },
18233
                                                    success: function (response) {
18234
                                                        var results = Ext.decode(response.responseText);
18235
                                                        var dt = results.data[0];
18236
                                                        if (dt != undefined) {
18237
                                                            custumFunc = dt.FunctionCode;
18238
                                                        }
18239
                                                    }
18240
                                                });
18241
                                            }
18242
                                            if (custumFunc) {
18243
                                                eval(custumFunc)
18244
                                            }
18245
                                        }
18246
                                    }
18247
                                }
18248
                            });
18249
                            break
18250
                        default:
18251
                            if (rec.DataRef == 'CREATEBY' || rec.DataRef == 'CHANGEBY' || rec.DataRef == 'CREATEDT' || rec.DataRef == 'CHANGEDT') {
18252
                                cols.push({
18253
                                    text: rec.HeaderTitle,
18254
                                    dataIndex: rec.FieldName,
18255
                                    width: 100,
18256
									minWidth: 150,
18257
                                    filter: {
18258
                                        type: 'string',
18259
                                        itemDefaults: {
18260
                                            emptyText: 'Search for...'
18261
                                        }
18262
                                    }
18263
                                });
18264
                            } else if (rec.SearchType == '0') {
18265
                                var valueField = null;
18266
                                var displayValue = null;
18267
                                var TableRef = undefined;
18268
                                if (rec.TableRef != '') {
18269
                                    TableRef = rec.TableRef;
18270
                                    Ext.Ajax.request({
18271
                                        async: false,
18272
                                        method: 'POST',
18273
                                        url: '/UserControl/GetStore',
18274
                                        params: {
18275
                                            tableName: 'SDATATABLEFIELD',
18276
                                            param: 'TableName[equal]' + rec.TableRef
18277
                                        },
18278
                                        success: function (response) {
18279
                                            var results = Ext.decode(response.responseText);
18280
                                            data_ = results.data;
18281
                                            if (data_ != undefined) {
18282
                                                valueField_ = $.grep(data_, function (r) {
18283
                                                    return r.ValueField == '1'
18284
                                                });
18285
                                                valueField = valueField_[0].FieldName
18286
                                                displayValue_ = $.grep(data_, function (r) {
18287
                                                    return r.DisplayValue == '1'
18288
                                                });
18289
                                                displayValue = displayValue_[0].FieldName
18290
                                            }
18291
                                        }
18292
                                    });
18293
                                }
18294
                                Ext.create('Ext.data.Store', {
18295
                                    storeId: 'store_' + me.tableName + rec.FieldName,
18296
                                    autoLoad: true,
18297
                                    proxy: {
18298
                                        method: 'POST',
18299
                                        type: 'ajax',
18300
                                        url: '/UserControl/GetStoreAuth',
18301
                                        extraParams: {
18302
                                            tableName: TableRef,
18303
                                            param: rec.ParamCombo,
18304
                                            menuId: MinovaUtil.GetMenuID()
18305
                                        },
18306
                                        reader: {
18307
                                            type: 'json',
18308
                                            root: 'data',
18309
                                            totalProperty: 'data[0].TotalCount'
18310
                                        }
18311
                                    }
18312
                                });
18313
                                cols.push({
18314
                                    xtype: 'minovacombocolumn',
18315
                                    hidden: Hidden_,
18316
                                    text: rec.HeaderTitle,
18317
                                    dataIndex: rec.FieldName,
18318
                                    valueField: valueField,
18319
                                    displayField: displayValue,
18320
                                    store: 'store_' + me.tableName + rec.FieldName,
18321
									minWidth: 150,
18322
                                    editor: {
18323
                                        allowBlank: null_,
18324
                                        xtype: 'minovacombobox',
18325
                                        readOnly: ReadOnly_,
18326
                                        id: tableName + rec.FieldName,
18327
                                        valueField: valueField,
18328
                                        displayField: displayValue,
18329
                                        store: 'store_' + me.tableName + rec.FieldName,
18330
										forceSelection: false,
18331
									lazyRender: true,
18332
                                        listeners: {
18333
                                            change: function (val) {
18334
                                                var fvalue = val.getValue();
18335
                                                var custumFunc = rec.SelectFunction;
18336
                                                if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
18337
                                                    Ext.Ajax.request({
18338
                                                        async: false,
18339
                                                        method: 'POST',
18340
                                                        url: '/UserControl/GetStore',
18341
                                                        params: {
18342
                                                            tableName: 'PCMFUNC',
18343
                                                            param: 'FuncName[equal]' + custumFunc + ',Active[=]1'
18344
                                                        },
18345
                                                        success: function (response) {
18346
                                                            var results = Ext.decode(response.responseText);
18347
                                                            var dt = results.data[0];
18348
                                                            if (dt != undefined) {
18349
                                                                custumFunc = dt.FunctionCode;
18350
                                                            }
18351
                                                        }
18352
                                                    });
18353
                                                }
18354
                                                if (custumFunc) {
18355
                                                    eval(custumFunc)
18356
                                                }
18357
                                            }
18358
                                        }
18359
                                    },
18360
                                    filter: {
18361
                                        type: 'list',
18362
                                        itemDefaults: {
18363
                                            emptyText: 'Search for...'
18364
                                        }
18365
                                    }
18366
                                });
18367
                            } else if (rec.SearchType == '5') {							
18368
                                var valueField = null;
18369
                                var displayValue = null;
18370
                                var AdditionaldisplayValue = null;
18371
                                var TableRef = undefined;
18372
                                if (rec.TableRef != '') {
18373
                                    TableRef = rec.TableRef;
18374
                                    Ext.Ajax.request({
18375
                                        async: false,
18376
                                        method: 'POST',
18377
                                        url: '/UserControl/GetStore',
18378
                                        params: {
18379
                                            tableName: 'SDATATABLEFIELD',
18380
                                            param: 'TableName[equal]' + rec.TableRef
18381
                                        },
18382
                                        success: function (response) {
18383
                                            var results = Ext.decode(response.responseText);
18384
                                            data_ = results.data;
18385
                                            if (data_ != undefined) {
18386
                                                valueField_ = $.grep(data_, function (r) {
18387
                                                    return r.ValueField == '1'
18388
                                                });
18389
                                                if (valueField_.length > 0) {
18390
                                                    valueField = valueField_[0].FieldName
18391
                                                }
18392

    
18393
                                                displayValue_ = $.grep(data_, function (r) {
18394
                                                    return r.DisplayValue == '1' || r.DisplayValue == '2'
18395
                                                });
18396
                                                if (displayValue_.length > 0) {
18397
                                                    displayValue = displayValue_[0].FieldName;
18398
                                                }
18399
                                                if (displayValue_.length >= 2) {
18400
                                                    AdditionaldisplayValue = displayValue_[1].FieldName
18401
                                                }
18402
                                            }
18403
                                        }
18404
                                    });
18405
                                }
18406
                                Ext.create('Ext.data.Store', {
18407
                                    storeId: 'store_' + me.tableName + rec.FieldName,
18408
                                    autoLoad: true,
18409
                                    proxy: {
18410
                                        method: 'POST',
18411
                                        type: 'ajax',
18412
                                        url: '/UserControl/GetStoreAuth',
18413
                                        extraParams: {
18414
                                            tableName: TableRef,
18415
                                            param: rec.ParamCombo,
18416
                                            menuId: MinovaUtil.GetMenuID()
18417
                                        },
18418
                                        reader: {
18419
                                            type: 'json',
18420
                                            root: 'data',
18421
                                            totalProperty: 'data[0].TotalCount'
18422
                                        }
18423
                                    }
18424
                                });
18425
                                cols.push({
18426
                                    xtype : 'minovacombocolumn',
18427
                                    hidden: Hidden_,
18428
                                    text: rec.HeaderTitle,
18429
                                    dataIndex: rec.FieldName,
18430
                                    valueField : valueField,
18431
                                    displayField : displayValue,
18432
                                    store : 'store_' + me.tableName + rec.FieldName,
18433
									minWidth: 150,
18434
                                    tpl: Ext.create('Ext.XTemplate',
18435
                                            '<ul class="x-list-plain"><tpl for=".">',
18436
                                            '<li role="option" class="x-boundlist-item">{' + AdditionaldisplayValue + '} - {' + displayValue + '}</li>',
18437
                                            '</tpl></ul>'),
18438
                                    displayTpl: Ext.create('Ext.XTemplate',
18439
                                        '<tpl for=".">',
18440
                                        '{' + AdditionaldisplayValue + '} - {' + displayValue + '}',
18441
                                        '</tpl>'),
18442
                                    editor: {
18443
                                        allowBlank: null_,
18444
                                        xtype: 'combobox',
18445
                                        readOnly: ReadOnly_,
18446
                                        id: rec.TableName + rec.FieldName,
18447
                                        nameTable: rec.TableName,
18448
                                        fieldGrid: rec.FieldName,
18449
                                        valueField: valueField,
18450
                                        displayField: displayValue,
18451
                                        store: 'store_' + me.tableName + rec.FieldName,
18452
                                        value: rec.DefaultValue,
18453
                                        tpl: Ext.create('Ext.XTemplate',
18454
                                            '<ul class="x-list-plain"><tpl for=".">',
18455
                                            '<li role="option" class="x-boundlist-item">{' + AdditionaldisplayValue + '} - {' + displayValue + '}</li>',
18456
                                            '</tpl></ul>'),
18457
                                        displayTpl: Ext.create('Ext.XTemplate',
18458
                                            '<tpl for=".">',
18459
                                            '{' + AdditionaldisplayValue + '} - {' + displayValue + '}',
18460
                                            '</tpl>')
18461
                                    },
18462
                                    renderer: function (value) {
18463
                                        var store = Ext.data.StoreManager.lookup('store_' + me.tableName + rec.FieldName);
18464
                                        var index = store.find(valueField, value);
18465
                                        var val = "";
18466
                                        if (index != -1) {
18467
                                            var rc = store.getAt(index);
18468
                                            //val = rc.get(displayValue);
18469
                                            val = rc.get(AdditionaldisplayValue) + ' - ' + rc.get(displayValue);
18470
                                        } else {
18471
                                            val = value;
18472
                                        }
18473
                                        return val;
18474
                                    },
18475
                                    filter: {
18476
                                        type: 'list',
18477
                                        itemDefaults: {
18478
                                            emptyText: 'Search for...'
18479
                                        }
18480
                                    }
18481
                                });
18482
                            } else if (rec.SearchType == '2') {
18483
                                var triger = (rec.TriggerCombo).split('$');
18484
                                var targetField_ = triger[0];
18485
                                var fieldValue_ = triger[1];
18486
                                cols.push({
18487
                                    text: rec.HeaderTitle,
18488
                                    hidden: Hidden_,
18489
                                    dataIndex: rec.FieldName,
18490
                                    filter: {
18491
                                        itemDefaults: {
18492
                                            emptyText: 'Search for...'
18493
                                        }
18494
                                    },
18495
                                    editor: {
18496
                                        allowBlank: null_,
18497
                                        xtype: 'minovalookupgrid',
18498
                                        readOnly: ReadOnly_,
18499
                                        isGrid: true,
18500
                                        fieldTarget: targetField_,
18501
                                        fieldValue: fieldValue_,
18502
                                        isGrid: true,
18503
                                        id: tableName + rec.FieldName,
18504
                                        tableName: rec.TableRef,
18505
                                        triggerCls: 'x-form-search-trigger',
18506
                                        vtype: 'alphanum',
18507
                                        listeners: {
18508
                                            change: function (val) {
18509
                                                var custumFunc = rec.SelectFunction;
18510
                                                if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
18511
                                                    Ext.Ajax.request({
18512
                                                        async: false,
18513
                                                        method: 'POST',
18514
                                                        url: '/UserControl/GetStore',
18515
                                                        params: {
18516
                                                            tableName: 'PCMFUNC',
18517
                                                            param: 'FuncName[equal]' + custumFunc + ',Active[=]1'
18518
                                                        },
18519
                                                        success: function (response) {
18520
                                                            var results = Ext.decode(response.responseText);
18521
                                                            data_ = results.data[0];
18522
                                                            if (data_ != undefined) {
18523
                                                                custumFunc = data_.FunctionCode;
18524
                                                            }
18525
                                                        }
18526
                                                    });
18527
                                                }
18528
                                                if (custumFunc) {
18529
                                                    eval(custumFunc)
18530
                                                }
18531
                                            }
18532
                                        }
18533
                                    }
18534
                                });
18535
                            } else if (rec.SearchType == '3') {
18536
                                cols.push({
18537
                                    text: rec.HeaderTitle,
18538
                                    hidden: Hidden_,
18539
                                    dataIndex: rec.FieldName,
18540
                                    filter: {
18541
                                        itemDefaults: {
18542
                                            emptyText: 'Search for...'
18543
                                        }
18544
                                    },
18545
                                    editor: {
18546
                                        allowBlank: null_,
18547
                                        xtype: 'MinovaLookupTree',
18548
                                        readOnly: ReadOnly_,
18549
                                        id: tableName + rec.FieldName,
18550
                                        tableName: rec.TableRef,
18551
                                        triggerCls: 'x-form-search-trigger',
18552
                                        vtype: 'alphanum',
18553
                                        treeSructure: rec.SearchFunction,
18554
                                        objClassValue: rec.ParamCombo,
18555
                                        listeners: {
18556
                                            change: function (val) {
18557
                                                var custumFunc = rec.SelectFunction;
18558
                                                if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
18559
                                                    Ext.Ajax.request({
18560
                                                        async: false,
18561
                                                        method: 'POST',
18562
                                                        url: '/UserControl/GetStore',
18563
                                                        params: {
18564
                                                            tableName: 'PCMFUNC',
18565
                                                            param: 'FuncName[equal]' + custumFunc + ',Active[=]1'
18566
                                                        },
18567
                                                        success: function (response) {
18568
                                                            var results = Ext.decode(response.responseText);
18569
                                                            data_ = results.data[0];
18570
                                                            if (data_ != undefined) {
18571
                                                                custumFunc = data_.FunctionCode;
18572
                                                            }
18573
                                                        }
18574
                                                    });
18575
                                                }
18576
                                                if (custumFunc) {
18577
                                                    eval(custumFunc)
18578
                                                }
18579
                                            }
18580
                                        }
18581
                                    }
18582
                                });
18583
                            } else if (rec.SearchType != '0' && rec.SearchType != '1' && rec.SearchType != '3' && (rec.FieldName == 'EmployeeID' || rec.FieldName == 'ApplicantID' || rec.FieldName == 'EmployeeIDFrom' || rec.FieldName == 'EmployeeIDTo') && isLookup != true) {
18584
                                var triger = (rec.TriggerCombo).split('&');
18585
                                var targetField_ = triger[0];
18586
                                var fieldValue_ = triger[0];
18587
                                cols.push({
18588
                                    text: rec.HeaderTitle,
18589
                                    hidden: Hidden_,
18590
                                    dataIndex: rec.FieldName,
18591
                                    filter: {
18592
                                        itemDefaults: {
18593
                                            emptyText: 'Search for...'
18594
                                        }
18595
                                    },
18596
                                    editor: {
18597
                                        allowBlank: null_,
18598
                                        xtype: 'lookupemployee',
18599
                                        readOnly: ReadOnly_,
18600
                                        isGrid: true,
18601
                                        fieldTarget: targetField_,
18602
                                        fieldValue: fieldValue_,
18603
                                        isGrid: true,
18604
                                        id: tableName + rec.FieldName,
18605
                                        tableName: rec.TableRef,
18606
                                        triggerCls: 'x-form-search-trigger',
18607
                                        vtype: 'alphanum',
18608
                                        listeners: {
18609
                                            change: function (val) {
18610
                                                var custumFunc = rec.SelectFunction;
18611
                                                if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
18612
                                                    Ext.Ajax.request({
18613
                                                        async: false,
18614
                                                        method: 'POST',
18615
                                                        url: '/UserControl/GetStore',
18616
                                                        params: {
18617
                                                            tableName: 'PCMFUNC',
18618
                                                            param: 'FuncName[equal]' + custumFunc + ',Active[=]1'
18619
                                                        },
18620
                                                        success: function (response) {
18621
                                                            var results = Ext.decode(response.responseText);
18622
                                                            data_ = results.data[0];
18623
                                                            if (data_ != undefined) {
18624
                                                                custumFunc = data_.FunctionCode;
18625
                                                            }
18626
                                                        }
18627
                                                    });
18628
                                                }
18629
                                                if (custumFunc) {
18630
                                                    eval(custumFunc)
18631
                                                }
18632
                                            }
18633
                                        }
18634
                                    }
18635
                                });
18636
                            } else if (rec.SearchType == '4' && isLookup != true) {
18637
                                cols.push({
18638
                                    text: rec.HeaderTitle,
18639
                                    hidden: Hidden_,
18640
                                    dataIndex: rec.FieldName,
18641
                                    filter: {
18642
                                        itemDefaults: {
18643
                                            emptyText: 'Search for...'
18644
                                        }
18645
                                    },
18646
                                    editor: {
18647
                                        allowBlank: null_,
18648
                                        xtype: 'lookupemployee',
18649
                                        readOnly: ReadOnly_,
18650
                                        isGrid: true,
18651
                                        fieldTarget: targetField_,
18652
                                        fieldValue: fieldValue_,
18653
                                        isGrid: true,
18654
                                        id: tableName + rec.FieldName,
18655
                                        tableName: rec.TableRef,
18656
                                        triggerCls: 'x-form-search-trigger',
18657
                                        vtype: 'alphanum',
18658
                                        listeners: {
18659
                                            change: function (val) {
18660
                                                var custumFunc = rec.SelectFunction;
18661
                                                if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
18662
                                                    Ext.Ajax.request({
18663
                                                        async: false,
18664
                                                        method: 'POST',
18665
                                                        url: '/UserControl/GetStore',
18666
                                                        params: {
18667
                                                            tableName: 'PCMFUNC',
18668
                                                            param: 'FuncName[equal]' + custumFunc + ',Active[=]1'
18669
                                                        },
18670
                                                        success: function (response) {
18671
                                                            var results = Ext.decode(response.responseText);
18672
                                                            data_ = results.data[0];
18673
                                                            if (data_ != undefined) {
18674
                                                                custumFunc = data_.FunctionCode;
18675
                                                            }
18676
                                                        }
18677
                                                    });
18678
                                                }
18679
                                                if (custumFunc) {
18680
                                                    eval(custumFunc)
18681
                                                }
18682
                                            }
18683
                                        }
18684
                                    }
18685
                                });
18686
                            } else if (rec.FixedValue != '') {
18687
                                cols.push({
18688
                                    text: rec.HeaderTitle,
18689
                                    hidden: Hidden_,
18690
                                    dataIndex: rec.FieldName,
18691
									
18692
                                    filter: {
18693
                                        itemDefaults: {
18694
                                            emptyText: 'Search for...'
18695
                                        }
18696
                                    },
18697
									autoSizeColumn: true,
18698
								width: 200,
18699
                                    editor: {
18700
                                        allowBlank: null_,
18701
                                        xtype: 'minovafixvalue',
18702
                                        readOnly: ReadOnly_,
18703
										forceSelection: false,
18704
                                        id: tableName + rec.FieldName,
18705
                                        nameTable: tableName,
18706
                                        fieldGrid: rec.FieldName,
18707
                                        fixedValue: rec.FixedValue,
18708
                                        valueField: 'code',
18709
                                        displayField: 'desc',
18710
                                        value: defaultValue,
18711
											/*Add by Midi 12 Juni 2019*/
18712
									listeners: {
18713
										change: function (val) {
18714
											var custumFunc = rec.SelectFunction;
18715
											if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
18716
												Ext.Ajax.request({
18717
													async: false,
18718
													method: 'POST',
18719
													url: '/UserControl/GetStore',
18720
													params: {
18721
														tableName: 'PCMFUNC',
18722
														param: 'FuncName[equal]' + custumFunc + ',Active[=]1'
18723
													},
18724
													success: function (response) {
18725
														var results = Ext.decode(response.responseText);
18726
														var dt = results.data[0];
18727
														if (dt != undefined) {
18728
															custumFunc = dt.FunctionCode;
18729
														}
18730
													}
18731
												});
18732
											}
18733
											if (custumFunc) {
18734
												eval(custumFunc)
18735
											}
18736
										}
18737
									}
18738
									//
18739
                                    },
18740
                                    renderer: function (value) {
18741
                                        var val = "";
18742
                                        var storeData = [];
18743
                                        var str = rec.FixedValue;
18744
                                        var hasil = str.split('||');
18745
                                        hasil.forEach(function (h) {
18746
                                            store_ = h.split('=')
18747
                                            storeData.push({
18748
                                                code: store_[0],
18749
                                                desc: store_[1]
18750
                                            });
18751
                                        });
18752
                                        var item = storeData.find(x => x.code == value);
18753
                                        if (item != undefined) {
18754
                                            val = item.desc;
18755
                                        }
18756
                                        return val;
18757
                                    }
18758
                                });
18759
                            } else if (rec.FieldDataType == 3) {
18760
                                cols.push({
18761
                                    text: rec.HeaderTitle,
18762
                                    hidden: Hidden_,
18763
                                    dataIndex: rec.FieldName,
18764
									isSummary:isSum,
18765
                                    filter: {
18766
                                        itemDefaults: {
18767
                                            emptyText: 'Search for...'
18768
                                        }
18769
                                    },
18770
								autoSizeColumn: true,
18771
								width: 200,
18772
                                    editor: {
18773
                                        allowBlank: null_,
18774
                                        xtype: 'textfield',
18775
                                        readOnly: ReadOnly_,
18776
                                        id: tableName + rec.FieldName,
18777
                                        nameTable: rec.TableName,
18778
                                        fieldGrid: rec.FieldName,
18779
                                        vtype: 'validateDecimal',
18780
                                        maxLength: rec.Length,
18781
                                        precision: rec.Prec,
18782
                                        fieldStyle: 'text-align:right;',
18783
                                        value: defaultValue,
18784
                                        listeners: {
18785
                                            change: function (val) {
18786
                                                var custumFunc = rec.SelectFunction;
18787
                                                if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
18788
                                                    Ext.Ajax.request({
18789
                                                        async: false,
18790
                                                        method: 'POST',
18791
                                                        url: '/UserControl/GetStore',
18792
                                                        params: {
18793
                                                            tableName: 'PCMFUNC',
18794
                                                            param: 'FuncName[equal]' + custumFunc + ',Active[=]1'
18795
                                                        },
18796
                                                        success: function (response) {
18797
                                                            var results = Ext.decode(response.responseText);
18798
                                                            var dt = results.data[0];
18799
                                                            if (dt != undefined) {
18800
                                                                custumFunc = dt.FunctionCode;
18801
                                                            }
18802
                                                        }
18803
                                                    });
18804
                                                }
18805
                                                if (custumFunc) {
18806
                                                    eval(custumFunc)
18807
                                                }
18808
                                            }
18809
                                        }
18810
                                    }
18811
                                });
18812
                            } else {
18813
                                cols.push({
18814
                                    text: rec.HeaderTitle,
18815
                                    hidden: Hidden_,
18816
                                    dataIndex: rec.FieldName,
18817
									// isSummary: isSum,
18818
                                    filter: {
18819
                                        itemDefaults: {
18820
                                            emptyText: 'Search for...'
18821
                                        }
18822
                                    },
18823
								autoSizeColumn: true,
18824
								width: 200,
18825
								minWidth: 150,
18826
                                    editor: {
18827
                                        allowBlank: null_,
18828
                                        xtype: 'textfield',
18829
                                        readOnly: ReadOnly_,
18830
                                        id: tableName + rec.FieldName,
18831
                                        value: defaultValue,
18832
                                        listeners: {
18833
                                            change: function (val) {
18834
                                                var custumFunc = rec.SelectFunction;
18835
                                                if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
18836
                                                    Ext.Ajax.request({
18837
                                                        async: false,
18838
                                                        method: 'POST',
18839
                                                        url: '/UserControl/GetStore',
18840
                                                        params: {
18841
                                                            tableName: 'PCMFUNC',
18842
                                                            param: 'FuncName[equal]' + custumFunc + ',Active[=]1'
18843
                                                        },
18844
                                                        success: function (response) {
18845
                                                            var results = Ext.decode(response.responseText);
18846
                                                            data_ = results.data[0];
18847
                                                            if (data_ != undefined) {
18848
                                                                custumFunc = data_.FunctionCode;
18849
                                                            }
18850
                                                        }
18851
                                                    });
18852
                                                }
18853
                                                if (custumFunc) {
18854
                                                    eval(custumFunc)
18855
                                                }
18856
                                            }
18857
                                        }
18858
                                    }
18859
                                });
18860
                            }
18861
                            break
18862
                    }
18863
                } else {
18864
                    cols.push({
18865
                        text: rec.HeaderTitle,
18866
                        hidden: Hidden_,
18867
                        dataIndex: rec.FieldName,
18868
                        hidden: true,
18869
                        editor: {
18870
                            allowBlank: true,
18871
                            xtype: 'textfield',
18872
                            readOnly: ReadOnly_,
18873
                            id: tableName + rec.FieldName,
18874
                            value: defaultValue
18875
                        },
18876
                        filter: {
18877
                            itemDefaults: {
18878
                                emptyText: 'Search for...'
18879
                            }
18880
                        }
18881
                    });
18882
                }
18883
            });
18884
        };
18885
        addData = addData + "})";
18886
        this.cellEditing = new Ext.grid.plugin.CellEditing({
18887
            clicksToEdit: 1
18888
        });
18889
        Ext.applyIf(me, {
18890
            items: [{
18891
                xtype: 'grid',
18892
                autoScroll: true,
18893
                id: gridName,
18894
                name: gridName,
18895
                height: height,
18896
                store: Ext.create('Ext.data.Store', {
18897
                    storeId: storeID,
18898
                    fields: fieldStore,
18899
                    proxy: {
18900
                        method: 'POST',
18901
                        type: 'ajax',
18902
                        url: '',
18903
                        reader: {
18904
                            type: 'json',
18905
                            root: 'data'
18906
                        }
18907
                    }
18908
                }),
18909
                dockedItems: [{
18910
                    xtype: 'toolbar',
18911
                    items: [{
18912
                        text: 'Add',
18913
                        name: 'add' + tableName,
18914
                        iconCls: 'fa-plus-circle',
18915
                        style: 'font-family: FontAwesome',
18916
                        handler: function () {
18917
                            var store = Ext.StoreMgr.lookup(storeID);
18918
                            var data = eval(addData);
18919
                            if (me.transType == "FIN") {
18920
                                var fp = Ext.ComponentQuery.query("[name=FiscalPeriod]")[0].getValue();
18921
                                var fy = Ext.ComponentQuery.query("[name=FiscalYear]")[0].getValue();
18922
                                var cp = Ext.ComponentQuery.query("[name=CompanyID]")[0].getValue();
18923
                                var bu = Ext.ComponentQuery.query("[name=BusinessUnit]")[0].getValue();
18924
                                data["FiscalPeriod"] = fp;
18925
                                data["FiscalYear"] = fy;
18926
                                data["CompanyID"] = cp;
18927
                                data["BusinessUnit"] = bu;
18928
                            }
18929
                            idx = store.getCount();
18930
                            store.insert(idx, data);
18931
                        }
18932
                    }, {
18933
                        text: 'Delete',
18934
                        name: 'delete' + tableName,
18935
                        iconCls: 'fa-trash-o',
18936
                        style: 'font-family: FontAwesome',
18937
                        handler: function () {
18938
                            var me = this,
18939
                            store = Ext.StoreMgr.lookup(storeID);
18940
                            var grid = Ext.getCmp(gridName);
18941
                            Ext.MessageBox.show({
18942
                                title: 'Remove tab',
18943
                                msg: "This will remove. Do you want to continue?",
18944
                                buttons: Ext.MessageBox.YESNO,
18945
                                fn: function (choice) {
18946
                                    console.log(choice);
18947
                                    if (choice === 'yes') {
18948
                                        var selection = grid.getView().getSelectionModel().getSelection()[0];
18949
                                        if (selection) {
18950
                                            store.remove(selection);
18951
                                        }
18952
                                    }
18953
                                }
18954
                            });
18955
                        }
18956
                    }
18957
					,{ //// add by Tri nwh 20211119
18958
                        text: 'Simulate',
18959
                        name: 'simulate' + tableName,
18960
                        //iconCls: 'fa-trash-o',
18961
                        style: 'font-family: FontAwesome',
18962
                        handler: function () {
18963
                            var me = this,
18964
                            store = Ext.StoreMgr.lookup(storeID);
18965
                            var grid = Ext.getCmp(gridName);
18966
							console.log(grid);
18967
                            //Ext.MessageBox.show({
18968
                                //title: 'Remove tab',
18969
                                //msg: "This will remove. Do you want to continue?",
18970
                                //buttons: Ext.MessageBox.YESNO,
18971
                                //fn: function (choice) {
18972
                                    //console.log(choice); console.log('jinyoung');
18973
                                    //if (choice === 'yes') {
18974
                                        //var selection = grid.getView().getSelectionModel().getSelection()[0];
18975
                                        //if (selection) {
18976
                                            //store.remove(selection);
18977
                                        //}
18978
                                    //}
18979
                                //}
18980
                            //});
18981
                        }
18982
                    }
18983
                    ]
18984
                }
18985
                ],
18986
                columns: cols,
18987
                selModel: {
18988
                    type: 'cellmodel'
18989
                },
18990
                plugins: [this.cellEditing],
18991
                //For Auto Size Coloum Mode - Nana
18992
                viewConfig: {
18993
                    emptyText: 'No Data Display',
18994
                    deferEmptyText: false,
18995
                    listeners: {
18996
                        refresh: function (dataview) {
18997
                            Ext.each(dataview.panel.columns, function (column) {
18998
                                if (column.autoSizeColumn == false)
18999
                                    column.autoSizeColumn = true;
19000
                                column.autoSize();
19001
                            })
19002
                        }
19003
                    }
19004
                },listeners: {
19005
					'beforeedit': function (editor, e, eOpts) {
19006
						if (e.colIdx == 2 && tableName == 'PTRMATERIALITEM') {
19007
							var store = Ext.StoreMgr.lookup('store_' + tableName + 'MaterialID');
19008
							var itemType = e.record.get('ItemType');
19009
							console.log(itemType);
19010
							if (itemType == '0') {
19011
								store.proxy.extraParams = {
19012
									tableName: 'PDSTRANSITEMS',
19013
									param: "TableName[=]PMDMAT0001",
19014
									menuId: MinovaUtil.GetMenuID()
19015
								};
19016
							} else if (itemType == '1') {
19017
								store.proxy.extraParams = {
19018
									tableName: 'PDSTRANSITEMS',
19019
									param: "TableName[=]PMDSRV0001",
19020
									menuId: MinovaUtil.GetMenuID()
19021
								};
19022
							} else if (itemType == '2') {
19023
								store.proxy.extraParams = {
19024
									tableName: 'PDSTRANSITEMS',
19025
									param: "TableName[=]PMDAST0001",
19026
									menuId: MinovaUtil.GetMenuID()
19027
								};
19028
							} else {
19029
								store.proxy.extraParams = {
19030
									tableName: '',
19031
									param: "",
19032
									menuId: MinovaUtil.GetMenuID()
19033
								};
19034
							}
19035
							store.removeAll();
19036
							store.reload();
19037
						}
19038
					}
19039
					}
19040
            }
19041
            ]
19042
        });
19043
        me.callParent(arguments);
19044
    }
19045
});
19046
/*Add by Taufan ( Generate Doc Transaction Cell Edit Grid Sum For ERP )*/
19047
Ext.define('MinovaUtil.MinovaES.MinovaDocGridCellEditSum', {
19048
	extend: 'Ext.form.Panel',
19049
	alias: 'widget.docgridcelleditsum',
19050
	requires: [
19051
		'Ext.grid.plugin.CellEditing',
19052
		'Ext.grid.Panel',
19053
		'Ext.grid.RowNumberer'
19054
	],
19055
	autoScroll: true,
19056
	anchor: '100%',
19057
	tableName: undefined,
19058
	docType: undefined,
19059
	transType: undefined,
19060
	docNo: undefined,
19061
	hideButton: undefined,
19062
	multiSelect: undefined,
19063
	initComponent: function () {
19064
		var me = this;
19065
		var isLookup = me.isLookup;
19066
		var hide_ = false;
19067
		var hideUploadDownload = false;
19068
		var widthLock = 250;
19069
		var checkSelection = '';
19070
		
19071
		Ext.Ajax.request({
19072
			async: false,
19073
			method: 'POST',
19074
			url: '/UserControl/GetStore',
19075
			params: {
19076
				tableName: "PCMBSTRANSLIST",
19077
				param: 'TableName[=]' + me.tableName
19078
			},
19079
			success: function (response) {
19080
				var results = Ext.decode(response.responseText);
19081
				if (results.data[0].UploadDownloadEnable == '0') {
19082
					hideUploadDownload = true;
19083
				} else {
19084
					hideUploadDownload = false;
19085
				}
19086
			}
19087
		});
19088

    
19089
		if (me.hideButton == true) {
19090
			hide_ = true;
19091
		}
19092
		if (me.multiSelect) {
19093
			locking = false;
19094
			checkSelection = 'checkboxmodel';
19095
			widthLock = 40;
19096
		}
19097
		var tableName = me.tableName;
19098
		var cols = [];
19099
		var fieldStore = [];
19100
		var _url = 'GetAllField';
19101
		var hasil = null;
19102
		var height = me.height;
19103
		var storeID = 'store' + me.tableName;
19104
		var gridName = 'grid' + me.name;
19105
		if (me.storeName) {
19106
			storeID = me.storeName;
19107
		}
19108
		var LangID = MinovaUtil.GetLangID();
19109
		var parameter = "LangID='" + LangID + "',TableName='" + me.tableName + "',DocType='" + me.docType + "'";
19110
		Ext.Ajax.request({
19111
			async: false,
19112
			method: 'POST',
19113
			url: '/UserControl/GetStore',
19114
			params: {
19115
				tableName: 'PDSDOCFIELD',
19116
				param: parameter
19117
			},
19118
			success: function (response) {
19119
				var results = Ext.decode(response.responseText);
19120
				hasil = results.data;
19121
			}
19122
		});
19123
		cols.push({
19124
			xtype: 'rownumberer'
19125
		});
19126
		var addData = '({';
19127
		if (hasil.length > 0) {
19128
			Ext.each(hasil, function (rec) {
19129
				fieldStore.push(rec.FieldName);
19130
				var defaultValue = rec.DefaultValue;
19131
				if (defaultValue.substring(0, 2).toLowerCase() == 'fn') {
19132
					Ext.Ajax.request({
19133
						async: false,
19134
						method: 'POST',
19135
						url: '/UserControl/GetStore',
19136
						params: {
19137
							tableName: 'PCMFUNC',
19138
							param: 'FuncName[equal]' + rec.DefaultValue
19139
						},
19140
						success: function (response) {
19141
							var results = Ext.decode(response.responseText);
19142
							data_ = results.data;
19143
							if (data_.length > 0) {
19144
								defaultValue = eval(data_[0].FunctionCode);
19145
							}
19146
						}
19147
					});
19148
				}
19149
				addData = addData + rec.FieldName + ":" + "'" + defaultValue + "',";
19150
				var null_ = null;
19151
				var ReadOnly_ = false;
19152
				if (rec.IsPrimaryKey == true) {
19153
					null_ = false;
19154
				}
19155
				if (rec.IsRequired == true) {
19156
					null_ = false;
19157
				} else {
19158
					null_ = true;
19159
				}
19160
				var Hidden_ = false;
19161
				if (rec.ReadOnly == '1') {
19162
					ReadOnly_ = true;
19163
				}
19164
				if (rec.IsHidden == '1' || rec.Sequence == '' || rec.Sequence == '0' || rec.ColumnNo == '' || rec.GridView == '') {
19165
					Hidden_ = true;
19166
					null_ = true;
19167
				}
19168
				var isSum = rec.IsSummary;
19169
				if (rec.GridView == 1) {
19170
					switch (rec.FormatRef) {
19171
					case "date":
19172
						cols.push({
19173
							xtype: 'minovadatecolumn',
19174
							hidden: Hidden_,
19175
							text: rec.HeaderTitle,
19176
							dataIndex: rec.FieldName,
19177
							filter: {
19178
								itemDefaults: {
19179
									emptyText: 'Search for...'
19180
								}
19181
							},
19182
							isSummary: isSum,
19183
							editor: {
19184
								allowBlank: null_,
19185
								xtype: 'datefield',
19186
								hideMode: 'visibility',
19187
								readOnly: ReadOnly_,
19188
								id: tableName + rec.FieldName,
19189
								value: defaultValue
19190
							}
19191
						});
19192
						break
19193
					case "amount":
19194
						cols.push({
19195
							xtype: 'numbercolumn',
19196
							text: rec.HeaderTitle,
19197
							align: 'right',
19198
							dataIndex: rec.FieldName,
19199
							isSummary: isSum,
19200
							hidden: Hidden_,
19201
							filter: {
19202
								itemDefaults: {
19203
									emptyText: 'Search for...'
19204
								}
19205
							},
19206
							autoSizeColumn: false,
19207
							width: 140,
19208
							editor: {
19209
								allowBlank: null_,
19210
								xtype: 'textfield',
19211
								readOnly: ReadOnly_,
19212
								id: tableName + rec.FieldName,
19213
								nameTable: rec.TableName,
19214
								fieldGrid: rec.FieldName,
19215
								fieldStyle: 'text-align:right;',
19216
								vtype: 'validateMinovaNumber',
19217
								value: '0',
19218
								listeners: {
19219
									change: function (val, recs) {
19220
										var fvalue = val.getValue();
19221
										var custumFunc = rec.SelectFunction;
19222
										if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
19223
											Ext.Ajax.request({
19224
												async: false,
19225
												method: 'POST',
19226
												url: '/UserControl/GetStore',
19227
												params: {
19228
													tableName: 'PCMFUNC',
19229
													param: 'FuncName[equal]' + custumFunc + ',Active[=]1'
19230
												},
19231
												success: function (response) {
19232
													var results = Ext.decode(response.responseText);
19233
													var dt = results.data[0];
19234
													if (dt != undefined) {
19235
														custumFunc = dt.FunctionCode;
19236
													}
19237
												}
19238
											});
19239
										}
19240
										if (custumFunc) {
19241
											eval(custumFunc)
19242
										}
19243
									}
19244
								}
19245
							}
19246
						});
19247
						break
19248
					default:
19249
						if (rec.DataRef == 'CREATEBY' || rec.DataRef == 'CHANGEBY' || rec.DataRef == 'CREATEDT' || rec.DataRef == 'CHANGEDT') {
19250
							cols.push({
19251
								text: rec.HeaderTitle,
19252
								dataIndex: rec.FieldName,
19253
								width: 100,
19254
								isSummary: isSum,
19255
								filter: {
19256
									type: 'string',
19257
									itemDefaults: {
19258
										emptyText: 'Search for...'
19259
									}
19260
								}
19261
							});
19262
						} else if (rec.SearchType == '0') {
19263
							var valueField = null;
19264
							var displayValue = null;
19265
							var TableRef = undefined;
19266
							if (rec.TableRef != '') {
19267
								TableRef = rec.TableRef;
19268
								Ext.Ajax.request({
19269
									async: false,
19270
									method: 'POST',
19271
									url: '/UserControl/GetStore',
19272
									params: {
19273
										tableName: 'SDATATABLEFIELD',
19274
										param: 'TableName[equal]' + rec.TableRef
19275
									},
19276
									success: function (response) {
19277
										var results = Ext.decode(response.responseText);
19278
										data_ = results.data;
19279
										if (data_ != undefined) {
19280
											valueField_ = $.grep(data_, function (r) {
19281
													return r.ValueField == '1'
19282
												});
19283
											valueField = valueField_[0].FieldName
19284
												displayValue_ = $.grep(data_, function (r) {
19285
													return r.DisplayValue == '1'
19286
												});
19287
											displayValue = displayValue_[0].FieldName
19288
										}
19289
									}
19290
								});
19291
							}
19292
							Ext.create('Ext.data.Store', {
19293
								storeId: 'store_' + me.tableName + rec.FieldName,
19294
								autoLoad: true,
19295
								proxy: {
19296
									method: 'POST',
19297
									type: 'ajax',
19298
									url: '/UserControl/GetStoreAuth',
19299
									extraParams: {
19300
										tableName: TableRef,
19301
										param: rec.ParamCombo,
19302
										menuId: MinovaUtil.GetMenuID()
19303
									},
19304
									reader: {
19305
										type: 'json',
19306
										root: 'data',
19307
										totalProperty: 'data[0].TotalCount'
19308
									}
19309
								}
19310
							});
19311
							cols.push({
19312
								xtype: 'minovacombocolumn',
19313
								hidden: Hidden_,
19314
								text: rec.HeaderTitle,
19315
								dataIndex: rec.FieldName,
19316
								valueField: valueField,
19317
								displayField: displayValue,
19318
								store: 'store_' + me.tableName + rec.FieldName,
19319
								isSummary: isSum,
19320
								autoSizeColumn: true,
19321
								width: 200,
19322
								minWidth: 150,
19323
								editor: {
19324
									allowBlank: null_,
19325
									xtype: 'minovacombobox',
19326
									readOnly: ReadOnly_,
19327
									id: tableName + rec.FieldName,
19328
									valueField: valueField,
19329
									displayField: displayValue,
19330
									store: 'store_' + me.tableName + rec.FieldName,
19331
									forceSelection: false,
19332
									lazyRender: true,
19333
									listeners: {
19334
										change: function (val) {
19335
											var fvalue = val.getValue();
19336
											var custumFunc = rec.SelectFunction;
19337
											if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
19338
												Ext.Ajax.request({
19339
													async: false,
19340
													method: 'POST',
19341
													url: '/UserControl/GetStore',
19342
													params: {
19343
														tableName: 'PCMFUNC',
19344
														param: 'FuncName[equal]' + custumFunc + ',Active[=]1'
19345
													},
19346
													success: function (response) {
19347
														var results = Ext.decode(response.responseText);
19348
														var dt = results.data[0];
19349
														if (dt != undefined) {
19350
															custumFunc = dt.FunctionCode;
19351
														}
19352
													}
19353
												});
19354
											}
19355
											if (custumFunc) {
19356
												eval(custumFunc)
19357
											}
19358
										}
19359
									}
19360
								},
19361
								filter: {
19362
									type: 'list',
19363
									itemDefaults: {
19364
										emptyText: 'Search for...'
19365
									}
19366
								}
19367
							});
19368
						} else if (rec.SearchType == '5') {
19369
							var valueField = null;
19370
							var displayValue = null;
19371
							var AdditionaldisplayValue = null;
19372
							var TableRef = undefined;
19373
							if (rec.TableRef != '') {
19374
								TableRef = rec.TableRef;
19375
								Ext.Ajax.request({
19376
									async: false,
19377
									method: 'POST',
19378
									url: '/UserControl/GetStore',
19379
									params: {
19380
										tableName: 'SDATATABLEFIELD',
19381
										param: 'TableName[equal]' + rec.TableRef
19382
									},
19383
									success: function (response) {
19384
										var results = Ext.decode(response.responseText);
19385
										data_ = results.data;
19386
										if (data_ != undefined) {
19387
											valueField_ = $.grep(data_, function (r) {
19388
													return r.ValueField == '1'
19389
												});
19390
											if (valueField_.length > 0) {
19391
												valueField = valueField_[0].FieldName
19392
											}
19393

    
19394
											displayValue_ = $.grep(data_, function (r) {
19395
													return r.DisplayValue == '1' || r.DisplayValue == '2'
19396
												});
19397
											if (displayValue_.length > 0) {
19398
												displayValue = displayValue_[0].FieldName;
19399
											}
19400
											if (displayValue_.length >= 2) {
19401
												AdditionaldisplayValue = displayValue_[1].FieldName
19402
											}
19403
										}
19404
									}
19405
								});
19406
							}
19407
							Ext.create('Ext.data.Store', {
19408
								storeId: 'store_' + me.tableName + rec.FieldName,
19409
								autoLoad: true,
19410
								proxy: {
19411
									method: 'POST',
19412
									type: 'ajax',
19413
									url: '/UserControl/GetStoreAuth',
19414
									extraParams: {
19415
										tableName: TableRef,
19416
										param: rec.ParamCombo,
19417
										menuId: MinovaUtil.GetMenuID()
19418
									},
19419
									reader: {
19420
										type: 'json',
19421
										root: 'data',
19422
										totalProperty: 'data[0].TotalCount'
19423
									}
19424
								}
19425
							});
19426
							cols.push({
19427
								xtype: 'minovacombocolumn',
19428
								hidden: Hidden_,
19429
								text: rec.HeaderTitle,
19430
								dataIndex: rec.FieldName,
19431
								valueField: valueField,
19432
								displayField: displayValue,
19433
								store: 'store_' + me.tableName + rec.FieldName,
19434
								tpl: Ext.create('Ext.XTemplate',
19435
									'<ul class="x-list-plain"><tpl for=".">',
19436
									'<li role="option" class="x-boundlist-item">{' + AdditionaldisplayValue + '} - {' + displayValue + '}</li>',
19437
									'</tpl></ul>'),
19438
								displayTpl: Ext.create('Ext.XTemplate',
19439
									'<tpl for=".">',
19440
									'{' + AdditionaldisplayValue + '} - {' + displayValue + '}',
19441
									'</tpl>'),
19442
								editor: {
19443
									allowBlank: null_,
19444
									xtype: 'combobox',
19445
									readOnly: ReadOnly_,
19446
									id: rec.TableName + rec.FieldName,
19447
									nameTable: rec.TableName,
19448
									fieldGrid: rec.FieldName,
19449
									valueField: valueField,
19450
									displayField: displayValue,
19451
									store: 'store_' + me.tableName + rec.FieldName,
19452
									value: rec.DefaultValue,
19453
									tpl: Ext.create('Ext.XTemplate',
19454
										'<ul class="x-list-plain"><tpl for=".">',
19455
										'<li role="option" class="x-boundlist-item">{' + AdditionaldisplayValue + '} - {' + displayValue + '}</li>',
19456
										'</tpl></ul>'),
19457
									displayTpl: Ext.create('Ext.XTemplate',
19458
										'<tpl for=".">',
19459
										'{' + AdditionaldisplayValue + '} - {' + displayValue + '}',
19460
										'</tpl>'),
19461
										listeners: {
19462
										change: function (val) {
19463
											var fvalue = val.getValue();
19464
											var custumFunc = rec.SelectFunction;
19465
											if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
19466
												Ext.Ajax.request({
19467
													async: false,
19468
													method: 'POST',
19469
													url: '/UserControl/GetStore',
19470
													params: {
19471
														tableName: 'PCMFUNC',
19472
														param: 'FuncName[equal]' + custumFunc + ',Active[=]1'
19473
													},
19474
													success: function (response) {
19475
														var results = Ext.decode(response.responseText);
19476
														var dt = results.data[0];
19477
														if (dt != undefined) {
19478
															custumFunc = dt.FunctionCode;
19479
														}
19480
													}
19481
												});
19482
											}
19483
											if (custumFunc) {
19484
												eval(custumFunc)
19485
											}
19486
										}
19487
									}
19488

    
19489
								},
19490
								renderer: function (value) {
19491
									var store = Ext.data.StoreManager.lookup('store_' + me.tableName + rec.FieldName);
19492
									console.log(store);
19493
									var index = store.find(valueField, value);
19494
									var val = "";
19495
									if (index != -1) {
19496
										var rc = store.getAt(index);
19497
										val = rc.get(AdditionaldisplayValue) + ' - ' + rc.get(displayValue);
19498
									} else {
19499
										val = value;
19500
									}
19501
									return val;
19502
								},
19503
								filter: {
19504
									type: 'list',
19505
									itemDefaults: {
19506
										emptyText: 'Search for...'
19507
									}
19508
								},
19509
								tpl: Ext.create('Ext.XTemplate',
19510
									'<ul class="x-list-plain"><tpl for=".">',
19511
									'<li role="option" class="x-boundlist-item">{' + AdditionaldisplayValue + '} - {' + displayValue + '}</li>',
19512
									'</tpl></ul>'),
19513
								displayTpl: Ext.create('Ext.XTemplate',
19514
									'<tpl for=".">',
19515
									'{' + AdditionaldisplayValue + '} - {' + displayValue + '}',
19516
									'</tpl>')
19517
							});
19518
						} else if (rec.SearchType == '2') {
19519
							var triger = (rec.TriggerCombo).split('$');
19520
							var targetField_ = triger[0];
19521
							var fieldValue_ = triger[1];
19522
							cols.push({
19523
								text: rec.HeaderTitle,
19524
								hidden: Hidden_,
19525
								dataIndex: rec.FieldName,
19526
								isSummary: isSum,
19527
								filter: {
19528
									itemDefaults: {
19529
										emptyText: 'Search for...'
19530
									}
19531
								},
19532
								autoSizeColumn: true,
19533
								width: 200,
19534
								editor: {
19535
									allowBlank: null_,
19536
									xtype: 'minovalookupgrid',
19537
									readOnly: ReadOnly_,
19538
									isGrid: true,
19539
									fieldTarget: targetField_,
19540
									fieldValue: fieldValue_,
19541
									isGrid: true,
19542
									id: tableName + rec.FieldName,
19543
									tableName: rec.TableRef,
19544
									triggerCls: 'x-form-search-trigger',
19545
									vtype: 'alphanum',
19546
									listeners: {
19547
										change: function (val) {
19548
											var custumFunc = rec.SelectFunction;
19549
											if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
19550
												Ext.Ajax.request({
19551
													async: false,
19552
													method: 'POST',
19553
													url: '/UserControl/GetStore',
19554
													params: {
19555
														tableName: 'PCMFUNC',
19556
														param: 'FuncName[equal]' + custumFunc + ',Active[=]1'
19557
													},
19558
													success: function (response) {
19559
														var results = Ext.decode(response.responseText);
19560
														var dt = results.data[0];
19561
														if (dt != undefined) {
19562
															custumFunc = dt.FunctionCode;
19563
														}
19564
													}
19565
												});
19566
											}
19567
											if (custumFunc) {
19568
												eval(custumFunc)
19569
											}
19570
										}
19571
									}
19572
								}
19573
							});
19574
						} else if (rec.SearchType == '3') {
19575
							cols.push({
19576
								text: rec.HeaderTitle,
19577
								hidden: Hidden_,
19578
								dataIndex: rec.FieldName,
19579
								isSummary: isSum,
19580
								filter: {
19581
									itemDefaults: {
19582
										emptyText: 'Search for...'
19583
									}
19584
								},
19585
								autoSizeColumn: true,
19586
								width: 200,
19587
								editor: {
19588
									allowBlank: null_,
19589
									xtype: 'MinovaLookupTree',
19590
									readOnly: ReadOnly_,
19591
									id: tableName + rec.FieldName,
19592
									tableName: rec.TableRef,
19593
									triggerCls: 'x-form-search-trigger',
19594
									vtype: 'alphanum',
19595
									treeSructure: rec.SearchFunction,
19596
									objClassValue: rec.ParamCombo,
19597
									listeners: {
19598
										change: function (val) {
19599
											var custumFunc = rec.SelectFunction;
19600
											if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
19601
												Ext.Ajax.request({
19602
													async: false,
19603
													method: 'POST',
19604
													url: '/UserControl/GetStore',
19605
													params: {
19606
														tableName: 'PCMFUNC',
19607
														param: 'FuncName[equal]' + custumFunc + ',Active[=]1'
19608
													},
19609
													success: function (response) {
19610
														var results = Ext.decode(response.responseText);
19611
														var dt = results.data[0];
19612
														if (dt != undefined) {
19613
															custumFunc = dt.FunctionCode;
19614
														}
19615
													}
19616
												});
19617
											}
19618
											if (custumFunc) {
19619
												eval(custumFunc)
19620
											}
19621
										}
19622
									}
19623
								}
19624
							});
19625
						} else if (rec.SearchType != '0' && rec.SearchType != '1' && rec.SearchType != '3' && (rec.FieldName == 'EmployeeID' || rec.FieldName == 'ApplicantID' || rec.FieldName == 'EmployeeIDFrom' || rec.FieldName == 'EmployeeIDTo') && isLookup != true) {
19626
							var triger = (rec.TriggerCombo).split('&');
19627
							var targetField_ = triger[0];
19628
							var fieldValue_ = triger[0];
19629
							cols.push({
19630
								text: rec.HeaderTitle,
19631
								hidden: Hidden_,
19632
								dataIndex: rec.FieldName,
19633
								isSummary: isSum,
19634
								filter: {
19635
									itemDefaults: {
19636
										emptyText: 'Search for...'
19637
									}
19638
								},
19639
								autoSizeColumn: true,
19640
								width: 200,
19641
								editor: {
19642
									allowBlank: null_,
19643
									xtype: 'lookupemployee',
19644
									readOnly: ReadOnly_,
19645
									isGrid: true,
19646
									fieldTarget: targetField_,
19647
									fieldValue: fieldValue_,
19648
									isGrid: true,
19649
									id: tableName + rec.FieldName,
19650
									tableName: rec.TableRef,
19651
									triggerCls: 'x-form-search-trigger',
19652
									vtype: 'alphanum',
19653
									listeners: {
19654
										change: function (val) {
19655
											var custumFunc = rec.SelectFunction;
19656
											if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
19657
												Ext.Ajax.request({
19658
													async: false,
19659
													method: 'POST',
19660
													url: '/UserControl/GetStore',
19661
													params: {
19662
														tableName: 'PCMFUNC',
19663
														param: 'FuncName[equal]' + custumFunc + ',Active[=]1'
19664
													},
19665
													success: function (response) {
19666
														var results = Ext.decode(response.responseText);
19667
														var dt = results.data[0];
19668
														if (dt != undefined) {
19669
															custumFunc = dt.FunctionCode;
19670
														}
19671
													}
19672
												});
19673
											}
19674
											if (custumFunc) {
19675
												eval(custumFunc)
19676
											}
19677
										}
19678
									}
19679
								}
19680
							});
19681
						} else if (rec.SearchType == '4' && isLookup != true) {
19682
							cols.push({
19683
								text: rec.HeaderTitle,
19684
								hidden: Hidden_,
19685
								dataIndex: rec.FieldName,
19686
								isSummary: isSum,
19687
								filter: {
19688
									itemDefaults: {
19689
										emptyText: 'Search for...'
19690
									}
19691
								},
19692
								autoSizeColumn: true,
19693
								width: 200,
19694
								editor: {
19695
									allowBlank: null_,
19696
									xtype: 'lookupemployee',
19697
									readOnly: ReadOnly_,
19698
									isGrid: true,
19699
									fieldTarget: targetField_,
19700
									fieldValue: fieldValue_,
19701
									isGrid: true,
19702
									id: tableName + rec.FieldName,
19703
									tableName: rec.TableRef,
19704
									triggerCls: 'x-form-search-trigger',
19705
									vtype: 'alphanum',
19706
									listeners: {
19707
										change: function (val) {
19708
											var custumFunc = rec.SelectFunction;
19709
											if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
19710
												Ext.Ajax.request({
19711
													async: false,
19712
													method: 'POST',
19713
													url: '/UserControl/GetStore',
19714
													params: {
19715
														tableName: 'PCMFUNC',
19716
														param: 'FuncName[equal]' + custumFunc + ',Active[=]1'
19717
													},
19718
													success: function (response) {
19719
														var results = Ext.decode(response.responseText);
19720
														var dt = results.data[0];
19721
														if (dt != undefined) {
19722
															custumFunc = dt.FunctionCode;
19723
														}
19724
													}
19725
												});
19726
											}
19727
											if (custumFunc) {
19728
												eval(custumFunc)
19729
											}
19730
										}
19731
									}
19732
								}
19733
							});
19734
						} else if (rec.FixedValue != '') {
19735
							cols.push({
19736
								text: rec.HeaderTitle,
19737
								hidden: Hidden_,
19738
								dataIndex: rec.FieldName,
19739
								isSummary: isSum,
19740
								filter: {
19741
									itemDefaults: {
19742
										emptyText: 'Search for...'
19743
									}
19744
								},
19745
								autoSizeColumn: true,
19746
								width: 200,
19747
								editor: {
19748
									allowBlank: null_,
19749
									xtype: 'minovafixvalue',
19750
									readOnly: ReadOnly_,
19751
									forceSelection: false,
19752
									id: tableName + rec.FieldName,
19753
									nameTable: tableName,
19754
									fieldGrid: rec.FieldName,
19755
									fixedValue: rec.FixedValue,
19756
									valueField: 'code',
19757
									displayField: 'desc',
19758
									value: defaultValue,
19759
									/*Add by Midi 12 Juni 2019*/
19760
									listeners: {
19761
										change: function (val) {
19762
											var custumFunc = rec.SelectFunction;
19763
											if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
19764
												Ext.Ajax.request({
19765
													async: false,
19766
													method: 'POST',
19767
													url: '/UserControl/GetStore',
19768
													params: {
19769
														tableName: 'PCMFUNC',
19770
														param: 'FuncName[equal]' + custumFunc + ',Active[=]1'
19771
													},
19772
													success: function (response) {
19773
														var results = Ext.decode(response.responseText);
19774
														var dt = results.data[0];
19775
														if (dt != undefined) {
19776
															custumFunc = dt.FunctionCode;
19777
														}
19778
													}
19779
												});
19780
											}
19781
											if (custumFunc) {
19782
												eval(custumFunc)
19783
											}
19784
										}
19785
									}
19786
									//
19787
								},
19788
								renderer: function (value) {
19789
									var val = "";
19790
									var storeData = [];
19791
									var str = rec.FixedValue;
19792
									var hasil = str.split('||');
19793
									hasil.forEach(function (h) {
19794
										store_ = h.split('=')
19795
											storeData.push({
19796
												code: store_[0],
19797
												desc: store_[1]
19798
											});
19799
									});
19800
									var item = storeData.find(x => x.code == value);
19801
									if (item != undefined) {
19802
										val = item.desc;
19803
									}
19804
									return val;
19805
								}
19806
							});
19807
						} else if (rec.FieldDataType == 3) {
19808
							cols.push({
19809
								text: rec.HeaderTitle,
19810
								hidden: Hidden_,
19811
								dataIndex: rec.FieldName,
19812
								isSummary: isSum,
19813
								filter: {
19814
									itemDefaults: {
19815
										emptyText: 'Search for...'
19816
									}
19817
								},
19818
								autoSizeColumn: true,
19819
								width: 200,
19820
								editor: {
19821
									allowBlank: null_,
19822
									xtype: 'textfield',
19823
									readOnly: ReadOnly_,
19824
									id: tableName + rec.FieldName,
19825
									nameTable: rec.TableName,
19826
									fieldGrid: rec.FieldName,
19827
									vtype: 'validateDecimal',
19828
									maxLength: rec.Length,
19829
									precision: rec.Prec,
19830
									fieldStyle: 'text-align:right;',
19831
									value: defaultValue,
19832
									listeners: {
19833
										change: function (val) {
19834
											var custumFunc = rec.SelectFunction;
19835
											if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
19836
												Ext.Ajax.request({
19837
													async: false,
19838
													method: 'POST',
19839
													url: '/UserControl/GetStore',
19840
													params: {
19841
														tableName: 'PCMFUNC',
19842
														param: 'FuncName[equal]' + custumFunc + ',Active[=]1'
19843
													},
19844
													success: function (response) {
19845
														var results = Ext.decode(response.responseText);
19846
														var dt = results.data[0];
19847
														if (dt != undefined) {
19848
															custumFunc = dt.FunctionCode;
19849
														}
19850
													}
19851
												});
19852
											}
19853
											if (custumFunc) {
19854
												eval(custumFunc)
19855
											}
19856
										}
19857
									}
19858
								}
19859
							});
19860
						} else {
19861
							cols.push({
19862
								text: rec.HeaderTitle,
19863
								hidden: Hidden_,
19864
								dataIndex: rec.FieldName,
19865
								isSummary: isSum,
19866
								filter: {
19867
									itemDefaults: {
19868
										emptyText: 'Search for...'
19869
									}
19870
								},
19871
								autoSizeColumn: true,
19872
								width: 200,
19873
								editor: {
19874
									allowBlank: null_,
19875
									xtype: 'textfield',
19876
									readOnly: ReadOnly_,
19877
									id: tableName + rec.FieldName,
19878
									value: defaultValue,
19879
									vtype: 'validateMinovaXss', //// Tri 20210906
19880
									listeners: {
19881
										change: function (val) {
19882
											var custumFunc = rec.SelectFunction;
19883
											if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
19884
												Ext.Ajax.request({
19885
													async: false,
19886
													method: 'POST',
19887
													url: '/UserControl/GetStore',
19888
													params: {
19889
														tableName: 'PCMFUNC',
19890
														param: 'FuncName[equal]' + custumFunc + ',Active[=]1'
19891
													},
19892
													success: function (response) {
19893
														var results = Ext.decode(response.responseText);
19894
														var dt = results.data[0];
19895
														if (dt != undefined) {
19896
															custumFunc = dt.FunctionCode;
19897
														}
19898
													}
19899
												});
19900
											}
19901
											if (custumFunc) {
19902
												eval(custumFunc)
19903
											}
19904
										}
19905
									}
19906
								}
19907
							});
19908
						}
19909
						break
19910
					}
19911
				} else {
19912
					cols.push({
19913
						text: rec.HeaderTitle,
19914
						hidden: Hidden_,
19915
						dataIndex: rec.FieldName,
19916
						isSummary: isSum,
19917
						hidden: true,
19918
						editor: {
19919
							allowBlank: true,
19920
							xtype: 'textfield',
19921
							readOnly: ReadOnly_,
19922
							id: tableName + rec.FieldName,
19923
							value: defaultValue,
19924
							vtype: 'validateMinovaXss' //// Tri 20210906
19925
						},
19926
						filter: {
19927
							itemDefaults: {
19928
								emptyText: 'Search for...'
19929
							}
19930
						}
19931
					});
19932
				}
19933
			});
19934
		};
19935
		addData = addData + "})";
19936
		Ext.applyIf(me, {
19937
			items: [{
19938
					xtype: 'grid',
19939
					autoScroll: true,
19940
					id: gridName,
19941
					name: gridName,
19942
					height: height,
19943
					store: Ext.create('Ext.data.Store', {
19944
						storeId: storeID,
19945
						fields: fieldStore,
19946
						proxy: {
19947
							method: 'POST',
19948
							type: 'ajax',
19949
							url: '',
19950
							reader: {
19951
								type: 'json',
19952
								root: 'data'
19953
							}
19954
						}
19955
					}),
19956
					dockedItems: [{
19957
							xtype: 'toolbar',
19958
							items: [{
19959
									text: 'Add',
19960
									hidden: hide_,
19961
									name: 'add' + tableName,
19962
									iconCls: 'fa-plus-circle',
19963
									style: 'font-family: FontAwesome',
19964
									handler: function () {
19965
										var store = Ext.StoreMgr.lookup(storeID);
19966
										var data = eval(addData);
19967
										if (me.transType == "FIN") {
19968
											var fp = Ext.ComponentQuery.query("[name=FiscalPeriod]")[0].getValue();
19969
											var fy = Ext.ComponentQuery.query("[name=FiscalYear]")[0].getValue();
19970
											var cp = Ext.ComponentQuery.query("[name=CompanyID]")[0].getValue();
19971
											var bu = Ext.ComponentQuery.query("[name=BusinessUnit]")[0].getValue();
19972
											var cc = Ext.ComponentQuery.query("[name=CostCenter]")[0].getValue();
19973
											// var desc = Ext.ComponentQuery.query("[name=Description]")[0].getValue();
19974
											data["FiscalPeriod"] = fp;
19975
											data["FiscalYear"] = fy;
19976
											data["CompanyID"] = cp;
19977
											data["BusinessUnit"] = bu;
19978
											// data["CostCenter"] = cc;
19979
											// data["Description"] = desc;
19980
										}
19981
										/*idx = store.getCount();
19982
										store.insert(idx, data);*/
19983
										
19984
										idx = store.getCount();
19985
										if(parseFloat(idx) <= 39) //// Tri 20210907
19986
										{
19987
											if(store.getCount() > 0) //// Tri nwh 20211111
19988
											{	console.log('siwan'); 
19989
												var IsCostCenter = '';
19990
												var grid = Ext.getCmp(gridName);
19991
												var selection = grid.getView().getSelectionModel().getSelection()[0];
19992
												if( selection != undefined)   //// add by Tri nwh 20211124
19993
												{
19994
													var GLAccountID = selection.data.GLAccountID;
19995
													var CostCenter = selection.data.CostCenter;
19996
													MinovaUtil.ExecuteParamQuery({
19997
														ID: 'FINANCEITEMISCOSTCENTER',
19998
														GlAccountID: GLAccountID
19999
													}, function (s) {
20000
														var result = Ext.decode(s.responseText);
20001
														var dt = Ext.decode(Ext.decode(result.data));
20002
														IsCostCenter = dt[0].CostCenter;
20003
													});
20004
												}
20005
												
20006
												if(IsCostCenter == '1')
20007
												{	console.log('chani');
20008
													var panelHead = Ext.ComponentQuery.query('[name=MainHeaderDocument]')[0];
20009
													var formheader = panelHead.getForm();
20010
													console.log(formheader.findField("DocStatus").getValue());
20011
													if(formheader.findField("DocStatus").getValue() == '9')
20012
													{
20013
														if(CostCenter == '' || CostCenter.isnull == true)
20014
														{	console.log('1');
20015
															alert('please fill field cost center'); 
20016
														}
20017
														else
20018
														{	console.log('2');
20019
															store.insert(idx, data);
20020
														}
20021
													}
20022
													else
20023
													{	console.log('3');
20024
														store.insert(idx, data);
20025
													}
20026
												}
20027
												else
20028
												{	console.log('4');
20029
													store.insert(idx, data);
20030
												}
20031
											}
20032
											else
20033
											{	console.log('5');
20034
												store.insert(idx, data);
20035
											}
20036
											//alert('nwh');
20037
											
20038
										}
20039
										else if (parseFloat(idx) > 39)
20040
										{
20041
											var tb = Ext.ComponentQuery.query('[name=panelTab]')[0];
20042
											var activeTab = tb.activeTab;
20043
											var tbl = activeTab.tbl;
20044
											var btnadd = Ext.ComponentQuery.query('[name=add' + tbl + ']')[0].setDisabled(true);
20045
											//alert('Can not insert data, because row data has reached the maximum');
20046
											alert('Anda sudah melebihi batas maksimal penginputan');
20047
										}
20048
									}
20049
	
20050
								}, {
20051
									text: 'Delete',
20052
									hidden: hide_,
20053
									name: 'delete' + tableName,
20054
									iconCls: 'fa-trash-o',
20055
									style: 'font-family: FontAwesome',
20056
									handler: function () {
20057
										var me = this,
20058
										store = Ext.StoreMgr.lookup(storeID)
20059
											var grid = Ext.getCmp(gridName);
20060
										Ext.MessageBox.show({
20061
											title: 'Remove tab',
20062
											msg: "This will remove. Do you want to continue?",
20063
											buttons: Ext.MessageBox.YESNO,
20064
											fn: function (choice) {
20065
												if (choice === 'yes') {
20066
													var selection = grid.getView().getSelectionModel().getSelection()[0];
20067
													if (selection) {
20068
														store.remove(selection);
20069
														var amountdebet = selection.data.AmountDebetCompCurr;  ////// add by tri yooma
20070
														var amountcredit = selection.data.AmountCreditCompCurr;
20071
														var totdebetexist = Ext.ComponentQuery.query('[name=TotalDebet]')[0].getValue().toString();
20072
														var totdebet =  parseFloat(totdebetexist.toString().replace(',', '')) - parseFloat(amountdebet);
20073
														var totcredit = parseFloat(Ext.ComponentQuery.query('[name=TotalCredit]')[0].getValue().toString().replace(',', '')) - amountcredit;
20074
														Ext.ComponentQuery.query('[name=TotalDebet]')[0].setValue(totdebet);
20075
														Ext.ComponentQuery.query('[name=AmountDebet]')[0].setValue(Ext.util.Format.number(totdebet, '0,000.00'));	
20076
														Ext.ComponentQuery.query('[name=TotalCredit]')[0].setValue(totcredit);
20077
														Ext.ComponentQuery.query('[name=AmountCredit]')[0].setValue(Ext.util.Format.number(totcredit, '0,000.00'));
20078
														//alert('nwh');
20079
													}
20080
												}
20081
											}
20082
										});
20083
									}
20084
								}, {
20085
									xtype: 'filefield',
20086
									buttonOnly: true,
20087
									buttonConfig: {
20088
										width: 160,
20089
										text: 'Upload',
20090
										ui: 'default-toolbar',
20091
										iconCls: 'icon-arrow-up',
20092
										style: 'font-family: FontAwesome',
20093
										hidden: hideUploadDownload,
20094
										name: 'upload' + tableName,
20095
										html: "<input id='inputFile' type='file' name='uploaded'/>",
20096
									},
20097
									listeners: {
20098
										change: function (f, value) {
20099
											var store = Ext.StoreMgr.lookup(storeID);
20100
											var newValue = '';
20101
											var afterDot = '';
20102
											var files = event.target.files;
20103
											var fileName = files[0].name;
20104
											var fileType = fileName.substr(fileName.indexOf('.'));
20105
											if (!files || files.length == 0) {
20106
												MinovaMessageError("File Error", "FILOFILE", "");
20107
											} else {
20108
												if (fileType == '.xls' || fileType == '.xlsx') {
20109
													var reader = new FileReader();
20110

    
20111
													//For Browsers other than IE.
20112
													if (reader.readAsBinaryString) {
20113
														reader.onload = function (e) {
20114
															var data = e.target.result;
20115
															//Read the Excel File data.
20116
															var workbook = XLSX.read(data, {
20117
																	type: 'binary'
20118
																});
20119
															//Fetch the name of First Sheet.
20120
															var firstSheet = workbook.SheetNames[0];
20121

    
20122
															//Read all rows from First Sheet into an JSON array.
20123
															var excelRows = XLSX.utils.sheet_to_row_object_array(workbook.Sheets[firstSheet]);
20124
															var data = eval(excelRows);
20125
															var dataLength = data.length;
20126
															idx = store.getCount();
20127
															var seq = idx + 1;
20128
															var dn = Ext.ComponentQuery.query("[name=DocNo]")[0].getValue();
20129
															for (var i = 0; i < dataLength; i++) {
20130
																data[i]["DocNo"] = dn;
20131
																data[i]["DocItemID"] = seq;
20132
																if (me.transType == "MTR" || me.transType == "PUR") {
20133
																	data[i].ARAPID = "";
20134
																	data[i].DocItemRef = "";
20135
																}
20136
																if (me.transType == "MTR") {
20137
																	data[i].Storage = "";
20138
																}
20139
																seq = seq + 1;
20140
															}
20141

    
20142
															var fields = store.model.getFields();
20143
															var gridFields = []
20144
															for (var i = 0; i < fields.length; i++) {
20145
																gridFields.push(fields[i].name);
20146
															}
20147

    
20148
															var index = [];
20149
															// build the index
20150
															for (var x in excelRows[0]) {
20151
																index.push(x);
20152
															}
20153
															var excelFields = []
20154
															for (var i = 0; i < index.length; i++) {
20155
																excelFields.push(index[i]);
20156
															}
20157

    
20158
															var template = [];
20159
															for (var i = 0; i < excelFields.length; i++) {
20160
																for (var j = 0; j < gridFields.length; j++) {
20161
																	if (excelFields[i] === gridFields[j]) {
20162
																		template.push(excelFields[i]);
20163
																	}
20164
																}
20165
															}
20166
															if (excelFields.length === template.length) {
20167
																store.insert(idx, data);
20168
															} else {
20169
																MinovaMessageError("Template Error", "FILOFILETEMPLATE", "");
20170
															}
20171
														};
20172
														reader.readAsBinaryString(files[0]);
20173

    
20174
													} else {
20175
														MinovaMessageError("FileReader Error", "FILOFILEREADER", "");
20176
													}
20177
												} else {
20178
													MinovaMessageError("File Type Error", "FILOUPLOAD", "");
20179
												}
20180
											}
20181
										}
20182
									}
20183
								}, {
20184
									text: 'Download',
20185
									hidden: hideUploadDownload,
20186
									name: 'download' + tableName,
20187
									iconCls: 'icon-arrow-down',
20188
									style: 'font-family: FontAwesome',
20189
									handler: function (b, e) {
20190
										b.up('grid').downloadExcelXml();
20191
									}
20192
								}
20193
							]
20194
						}
20195
					],
20196
					columns: cols,
20197
					selType: 'cellmodel',
20198
					plugins: [
20199
						Ext.create('Ext.grid.plugin.CellEditing', {
20200
							clicksToEdit: 1
20201
						})
20202
					],
20203
					//Add For Auto Size Coloum Mode - Nana
20204
					viewConfig: {
20205
						emptyText: 'No Data Display',
20206
						deferEmptyText: false,
20207
						listeners: {
20208
							refresh: function (dataview) {
20209
								Ext.each(dataview.panel.columns, function (column) {
20210
									if (column.autoSizeColumn == true)
20211
									column.autoSize();
20212
								})
20213
							}
20214
						}
20215
					},
20216
					listeners: {
20217
						'edit': function (editor, e, eOpts) {
20218
							/*Update By Midi 13 Juni 2019*/
20219
							var sumPanel = Ext.ComponentQuery.query('[name=SUM' + tableName + ']')[0];
20220
							var sumForm = sumPanel.getForm();
20221
							var grid = Ext.ComponentQuery.query('[name=' + gridName + ']')[0];
20222
							var sumFields = sumForm.getFields();
20223
							for (var i = 0; i < sumFields.length; i++) {
20224
								var fField = sumFields.items[i].name;
20225
								var fldValue = 0;
20226
								Ext.each(grid.store.getRange(), function (r) {
20227
									var fValue = r.data[fField];
20228
									fldValue = fldValue + parseFloat(fValue);
20229
								});
20230
								
20231
								fldValue = Ext.util.Format.number(fldValue, '0,000.00');
20232
								sumForm.findField(fField).setValue(fldValue);
20233
								if (fField.toLowerCase().includes("cred")) {
20234
                                    if (Ext.ComponentQuery.query('[name=TotalCredit]')[0] != undefined) {
20235
                                        Ext.ComponentQuery.query('[name=TotalCredit]')[0].setValue(fldValue);
20236
                                    }
20237
                                }
20238
                                if (fField.toLowerCase().includes("deb")) {
20239
                                    if (Ext.ComponentQuery.query('[name=TotalDebet]')[0] != undefined) {
20240
                                        Ext.ComponentQuery.query('[name=TotalDebet]')[0].setValue(fldValue);
20241
                                    }
20242
                                }
20243
							}							
20244
							// var grid = Ext.ComponentQuery.query('[name=' + gridName + ']')[0];
20245
							// var fField = e.field;
20246
							// if (e.column.isSummary == '1') {
20247
								// var fldValue = 0;
20248
								// Ext.each(grid.store.getRange(), function (r) {
20249
									// var fValue = r.data[fField];
20250
									// fldValue = fldValue + parseFloat(fValue);
20251
								// });
20252
								// var sumPanel = Ext.ComponentQuery.query('[name=SUM' + tableName + ']')[0];
20253
								// var sumForm = sumPanel.getForm();
20254
								// fldValue = Ext.util.Format.number(fldValue, '0,000.00');
20255
								// sumForm.findField(fField).setValue(fldValue);
20256
							// }
20257
						}
20258
						// ,
20259
						/*Add By Midi For Store Combobox With Param In Grid */
20260
						// 'beforeedit': function (editor, e, eOpts) {
20261
							// if (e.colIdx == 1 && tableName == 'PTRPURCHITEM') {
20262
								// var store = Ext.StoreMgr.lookup('store_' + tableName + 'Material');
20263
								// var itemType = e.record.get('ItemType');
20264
								// store.clearFilter();
20265
								// store.filter('MaterialType', itemType);
20266
							// }
20267
							// // if (e.colIdx == 1 && tableName == 'PTRFINANCEITEM') {
20268
								// // var store = Ext.StoreMgr.lookup('store_' + tableName + 'GLAccountID');
20269
								// // var itemType = e.record.get('CompanyID');
20270
								// // store.clearFilter();
20271
								// // store.filter('CompanyID', itemType);
20272
							// // }
20273
						// }
20274
					}
20275
				}
20276
			]
20277
		});
20278
		me.callParent(arguments);
20279
	}
20280
});
20281
Ext.define('MinovaUtil.MinovaES.LookupDoc', {
20282
	extend : 'Ext.window.Window',
20283
	alias : 'widget.lookupdocument',
20284
	requires : [],
20285
	height : '87%',
20286
	width : '41%',
20287
	minWidth : '50%',
20288
	maxWidth : '100%',
20289
	bodyPadding : 0,
20290
	formname : undefined,
20291
	name : 'LookupDocumentTrans',
20292
	test : undefined,
20293
	vtype : 'validateMinovaXss',
20294
	targetField : undefined,
20295
	valueField : undefined,
20296
	tableName : undefined,
20297
	LookupFunction : undefined,
20298
	isGrid : undefined,
20299
	listeners : {
20300
		afterrender : function (f) {
20301
			f.setTitle('Lookup - Document');
20302
		}
20303
	},
20304
	initComponent : function () {
20305
		var me = this;
20306
		var targetField_ = me.targetField;
20307
		var valueField_ = me.valueField;
20308
		var form = me.test;
20309
		var tableName_ = me.tableName;
20310
		var isGrid = me.isGrid_;
20311
		var LookupFunction = me.LookupFunction;
20312
		param_ = null;
20313
		var filterParam_ = me.filterParam;
20314
		var fieldLabel_ = 'Document No';
20315
		Ext.applyIf(me, {
20316
			items : [{
20317
					items : [{
20318
							xtype : 'tabpanel',
20319
							items : [{
20320
									xtype : 'form',
20321
									title : 'Quick Search',
20322
									height : '70%',
20323
									items : [{
20324
											xtype : 'form',
20325
											name : 'frmSearch',
20326
											width : '100%',
20327
											height : 'auto',
20328
											dockedItems : [{
20329
													xtype : 'toolbar',
20330
													dock : 'top',
20331
													layout : 'vbox',
20332
													bodyPadding : 10,
20333
													border : 0,
20334
													items : [{
20335
															xtype : 'fieldset',
20336
															layout : 'hbox',
20337
															width : '100%',
20338
															border : 0,
20339
															padding : 0,
20340
															items : [{
20341
																	xtype : 'textfield',
20342
																	name : 'DocSearch',
20343
																	fieldLabel : fieldLabel_,
20344
																	width : 470,
20345
																	labelWidth : 185,
20346
																	enableKeyEvents : true,
20347
																	filterParam : filterParam_,
20348
																	listeners : {
20349
																		specialkey : function (f, e) {
20350
																			if (e.getKey() == e.ENTER) {
20351
																				var doc = Ext.ComponentQuery.query('[name=DocSearch]')[0];
20352
																				var docNo = doc.getValue();
20353
																				var store = Ext.data.StoreManager.lookup('storeQC');
20354
																				param_ = 'DocNo[like]' + docNo
20355
																					if (this.filterParam) {
20356
																						param_ = param_ + ',' + this.filterParam_
20357
																					}
20358
																					store.proxy.extraParams = {
20359
																					tableName : tableName_,
20360
																					param : param_,
20361
																					menuId : MinovaUtil.GetMenuID()
20362
																				};
20363
																				store.removeAll();
20364
																				store.reload();
20365
																				store.loadPage(1);
20366
																			}
20367
																		}
20368
																	}
20369
																}, {
20370
																	xtype : 'tbspacer',
20371
																	width : 5
20372
																}, {
20373
																	xtype : 'button',
20374
																	name : 'Search',
20375
																	text : 'Search',
20376
																	filterParam : filterParam_,
20377
																	handler : function () {
20378
																		var doc = Ext.ComponentQuery.query('[name=DocSearch]')[0];
20379
																		var docNo = doc.getValue();
20380
																		var store = Ext.data.StoreManager.lookup('storeQC');
20381
																		param_ = 'DocNo[like]' + docNo
20382
																			if (this.filterParam) {
20383
																				param_ = param_ + ',' + this.filterParam
20384
																			}
20385
																			store.proxy.extraParams = {
20386
																			tableName : tableName_,
20387
																			param : param_,
20388
																			menuId : MinovaUtil.GetMenuID()
20389
																		};
20390
																		store.removeAll();
20391
																		store.reload();
20392
																		store.loadPage(1);
20393
																	}
20394
																}
20395
															]
20396
														}
20397
													]
20398
												}
20399
											]
20400
										}, {
20401
											items : [{
20402
													xtype : "minovagrid1",
20403
													name : "GridDocNo",
20404
													storename : 'storeQC',
20405
													tableName : tableName_,
20406
													param : this.filterParam,
20407
													isLookup : true,
20408
													pagesize : 25,
20409
													height : 398,
20410
													LookupFunction : LookupFunction,
20411
													valueField : valueField_,
20412
													targetField : targetField_,
20413
													isGrid : true,
20414
													listeners : {
20415
														beforeedit : function () {
20416
															return false;
20417
														},
20418
														itemdblclick : function () {
20419
															var grid = Ext.ComponentQuery.query('[name=GridDocNo]')[0];
20420
															var selection = grid.getView().getSelectionModel().getSelection()[0];
20421
															var documentno = selection.data.DocNo;
20422
															LookupFunction = this.LookupFunction;
20423
															eval(LookupFunction);
20424
															var target = Ext.ComponentQuery.query('[name=LookupDocumentTrans]')[0].targetField;
20425
															Ext.ComponentQuery.query('[name=' + target + ']')[0].setValue(documentno);
20426
															Ext.ComponentQuery.query('[name=LookupDocumentTrans]')[0].hide();
20427
														}
20428
													},
20429
												}, {
20430
													xtype : 'pagingtoolbar',
20431
													store : 'storeQC',
20432
													dock : 'bottom',
20433
													displayInfo : true
20434
												}
20435
											]
20436
										}
20437
									]
20438
								}, {
20439
									title : 'Advance Search',
20440
									items : [{
20441
											xtype : 'form',
20442
											name : 'formlookup',
20443
											items : [{
20444
													xtype : 'minovaform',
20445
													name : 'frmlookup',
20446
													tableName : tableName_,
20447
													param : filterParam_,
20448
													isLookup : true,
20449
													buttons : [{
20450
															text : 'Search',
20451
															filterParam : filterParam_,
20452
															listeners : {
20453
																click : function () {
20454
																	var store = Ext.data.StoreManager.lookup('storeadvance');
20455
																	var form = Ext.ComponentQuery.query('[name=formlookup]')[0].getForm();
20456
																	grid = Ext.ComponentQuery.query('[name=gridlookup]')[0];
20457
																	var values_ = form.getValues();
20458
																	var fields_ = form.getFields().items;
20459
																	var param_ = '';
20460
																	for (var i = 0; i < fields_.length; i++) {
20461
																		var val_ = form.getFields().items[i].getValue();
20462
																		var xtype_ = form.getFields().items[i].xtype;
20463
																		var oprator_ = '[like]';
20464
																		if (xtype_ == 'combobox' || xtype_ == 'combo' || xtype_ == 'minovacombo' || xtype_ == 'minovacombobox') {
20465
																			oprator_ = '[Equal]';
20466
																		}
20467
																		if (xtype_ == 'datefield') {
20468
																			if (form.getFields().items[i].name == 'StartDate' || form.getFields().items[i].name == 'ValidForm') {
20469
																				oprator_ = '[LessThanEqual]';
20470
																			} else {
20471
																				oprator_ = '[GreaterThanEqual]';
20472
																			}
20473
																		}
20474
																		if (val_ != 'undefined' && val_ != "" && val_ != null) {
20475
																			param_ = param_ + ',' + form.getFields().items[i].name + oprator_ + val_;
20476
																		}
20477
																	}
20478
																	if (this.filterParam_) {
20479
																		param_ = param_ + ',' + this.filterParam_
20480
																	}
20481
																	store.proxy.extraParams = {
20482
																		tableName : grid.tableName,
20483
																		param : param_,
20484
																		menuId : MinovaUtil.GetMenuID()
20485
																	};
20486
																	store.removeAll();
20487
																	store.reload();
20488
																	store.loadPage(1);
20489
																}
20490
															}
20491
														}
20492
													]
20493
												}, {
20494
													xtype : 'minovagrid1',
20495
													name : 'gridlookup',
20496
													minHeight : 312,
20497
													height : 290,
20498
													tableName : tableName_,
20499
													param : this.filterParam,
20500
													isLookup : true,
20501
													storename : 'storeadvance',
20502
													pagesize : 25,
20503
													valueField : valueField_,
20504
													targetField : targetField_,
20505
													hidebutton : 0,
20506
													isGrid : true,
20507
													listeners : {
20508
														beforeedit : function () {
20509
															return false;
20510
														},
20511
														itemdblclick : function () {
20512
															var grid = Ext.ComponentQuery.query('[name=gridlookup]')[0];
20513
															var selection = grid.getView().getSelectionModel().getSelection()[0];
20514
															var documentno = selection.data.DocNo;
20515
															LookupFunction = this.LookupFunction;
20516
															eval(LookupFunction);
20517
															var target = Ext.ComponentQuery.query('[name=LookupDocumentTrans]')[0].targetField;
20518
															Ext.ComponentQuery.query('[name=' + target + ']')[0].setValue(documentno);
20519
															Ext.ComponentQuery.query('[name=LookupDocumentTrans]')[0].hide();
20520
														}
20521
													},
20522
													dockedItems : [{
20523
															xtype : 'pagingtoolbar',
20524
															store : 'storeadvance',
20525
															dock : 'bottom',
20526
															displayInfo : true
20527
														}
20528
													]
20529
												}
20530
											]
20531
										}
20532
									]
20533
								}
20534
							]
20535
						}
20536
					]
20537
				}
20538
			]
20539
		});
20540
		me.callParent(arguments);
20541
	}
20542
});
20543
Ext.define('MinovaUtil.MinovaES.MinovaSummaryDocForm', {
20544
	extend : 'Ext.form.Panel',
20545
	alias : ['widget.summarydocform'],
20546
	formname : this.name,
20547
	tableName : undefined,
20548
	docType : undefined,
20549
	transType : undefined,
20550
	resizable : true,
20551
	border : false,
20552
	autoScroll : true,
20553
	layout : 'column',
20554
	defaults : {
20555
		layout : 'form',
20556
		xtype : 'container',
20557
		defaultType : 'textfield',
20558
		style : 'width: 50%',
20559
	},
20560
	initComponent : function () {
20561
		var me = this;
20562
		var col1 = [];
20563
		var col2 = [];
20564
		var LangID = localStorage.LangId;
20565
		var parameter = "LangID='" + LangID + "',TableName='" + me.tableName + "',DocType='" + me.docType + "',IsSummary=1";
20566
		var formname_ = me.name;
20567
		var nameTable_ = me.tableName;
20568
		Ext.Ajax.request({
20569
			async : false,
20570
			method : 'POST',
20571
			url : '/UserControl/GetStore',
20572
			params : {
20573
				tableName : 'PDSDOCFIELD',
20574
				param : parameter
20575
			},
20576
			success : function (response) {
20577
				var results = Ext.decode(response.responseText);
20578
				hasil = results.data;
20579
			}
20580
		});
20581
		if (hasil.length > 0) {
20582
			Ext.each(hasil, function (rec) {
20583
				var formfield = MinovaUtil.FieldGenerator.Form(me.name, rec, false, true, me.tableName, false);
20584
				var descField = undefined;
20585
				if (rec.ColumnNo == 1) {
20586
					col1.push(formfield);
20587
					if (descField) {
20588
						col1.push(descField)
20589
					}
20590
				} else {
20591
					col2.push(formfield);
20592
					if (descField) {
20593
						col2.push(descField)
20594
					}
20595
				}
20596
			});
20597
		}
20598
		Ext.applyIf(me, {
20599
			items : [{
20600
					style : 'width: 50%',
20601
					items : col1
20602
				}, {
20603
					style : 'width: 50%',
20604
					items : col2
20605
				}
20606
			]
20607
		});
20608
		this.callParent();
20609
	}
20610
});
20611
Ext.define('MinovaUtil.MinovaES.LookupDocRef', {
20612
	extend : 'Ext.window.Window',
20613
	alias : 'widget.lookupdocumentref',
20614
	requires : [],
20615
	height : '87%',
20616
	width : '41%',
20617
	minWidth : '50%',
20618
	maxWidth : '100%',
20619
	bodyPadding : 0,
20620
	formname : undefined,
20621
	name : 'LookupDocRef',
20622
	test : undefined,
20623
	vtype : 'validateMinovaXss',
20624
	targetField : undefined,
20625
	valueField : undefined,
20626
	tableName : 'PDSDOCREF',
20627
	transType : undefined,
20628
	docType : undefined,
20629
	LookupFunction : undefined,
20630
	datarecord : undefined,
20631
	isGrid : undefined,
20632
	filterParam : undefined,
20633
	listeners : {
20634
		afterrender : function (f) {
20635
			f.setTitle('Lookup - Document');
20636
		}
20637
	},
20638
	initComponent : function () {
20639
		var me = this;
20640
		var targetField_ = me.targetField;
20641
		var valueField_ = me.valueField;
20642
		var form = me.test;
20643
		var tableName_ = me.tableName;
20644
		var isGrid = me.isGrid_;
20645
		var LookupFunction = me.LookupFunction;
20646
		param_ = null;
20647
		var filterParam_ = me.filterParam;
20648
		var compselect = "";
20649
		var buselect = "";
20650
		Ext.applyIf(me, {
20651
			items : [{
20652
					xtype : 'form',
20653
					name : 'formlookup',
20654
					items : [{
20655
							xtype : 'minovaform',
20656
							name : 'frmlookup',
20657
							tableName : tableName_,
20658
							param : filterParam_,
20659
							isLookup : true,
20660
							buttons : [{
20661
									text : 'Search',
20662
									filterParam : filterParam_,
20663
									listeners : {
20664
										click : function () {
20665
											var store = Ext.data.StoreManager.lookup('storeadvance');
20666
											var form = Ext.ComponentQuery.query('[name=formlookup]')[0].getForm();
20667
											grid = Ext.ComponentQuery.query('[name=gridlookupdocref]')[0];
20668
											var values_ = form.getValues();
20669
											var fields_ = form.getFields().items;
20670
											var param_ = '';
20671
											for (var i = 0; i < fields_.length; i++) {
20672
												var val_ = form.getFields().items[i].getValue();
20673
												var xtype_ = form.getFields().items[i].xtype;
20674
												var oprator_ = '[like]';
20675
												if (xtype_ == 'combobox' || xtype_ == 'combo' || xtype_ == 'minovacombo' || xtype_ == 'minovacombobox') {
20676
													oprator_ = '[Equal]';
20677
												}
20678
												if (xtype_ == 'datefield') {
20679
													if (form.getFields().items[i].name == 'StartDate' || form.getFields().items[i].name == 'ValidForm') {
20680
														oprator_ = '[LessThanEqual]';
20681
													} else {
20682
														oprator_ = '[GreaterThanEqual]';
20683
													}
20684
												}
20685
												if (val_ != 'undefined' && val_ != "" && val_ != null) {
20686
													param_ = param_ + ',' + form.getFields().items[i].name + oprator_ + val_;
20687
												}
20688
											}
20689
											if (filterParam_) {
20690
												param_ = param_ + ',' + filterParam_
20691
											}
20692
											store.proxy.extraParams = {
20693
												tableName : grid.tableName,
20694
												param : param_,
20695
												menuId : MinovaUtil.GetMenuID()
20696
											};
20697
											store.removeAll();
20698
											store.reload();
20699
											store.loadPage(1);
20700
										}
20701
									}
20702
								}
20703
							]
20704
						}, {
20705
							xtype : 'minovagrid1',
20706
							name : 'gridlookupdocref',
20707
							minHeight : 312,
20708
							height : 290,
20709
							tableName : tableName_,
20710
							param : this.filterParam,
20711
							isLookup : true,
20712
							storename : 'storeadvance',
20713
							pagesize : 25,
20714
							valueField : valueField_,
20715
							targetField : targetField_,
20716
							multiSelect : true,
20717
							hidebutton : 0,
20718
							isGrid : true,
20719
							listeners : {
20720
								beforeedit : function () {
20721
									return false;
20722
								},
20723
								itemdblclick : function () {},
20724
								select : function (t, record, index, eOpts) {
20725
									if (compselect !== "") {
20726
										if (compselect !== record.data.CompanyID) {
20727
											// MinovaMessageError("", "FILO06", "");
20728
											return;
20729
										}
20730
									}
20731
									if (buselect !== "") {
20732
										if (buselect !== record.data.BusinessUnit) {
20733
											// MinovaMessageError("", "FILO07", "");
20734
											return;
20735
										}
20736
									}
20737
									compselect = record.data.CompanyID;
20738
									buselect = record.data.BusinessUnit;
20739
								}
20740
							},
20741
							dockedItems : [{
20742
									xtype : 'pagingtoolbar',
20743
									store : 'storeadvance',
20744
									dock : 'bottom',
20745
									displayInfo : true
20746
								}, {
20747
									xtype : 'button',
20748
									name : 'select',
20749
									text : 'Select',
20750
									dock : 'bottom'
20751
								}
20752
							]
20753
						}
20754
					]
20755
				}
20756
			]
20757
		});
20758
		me.callParent(arguments);
20759
	}
20760
});
20761
var Base64 = (function () {
20762
	// Private property
20763
	var keyStr = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
20764

    
20765
	// Private method for UTF-8 encoding
20766

    
20767
	function utf8Encode(string) {
20768
		string = string.replace(/\r\n/g, "\n");
20769
		var utftext = "";
20770
		for (var n = 0; n < string.length; n++) {
20771
			var c = string.charCodeAt(n);
20772
			if (c < 128) {
20773
				utftext += String.fromCharCode(c);
20774
			} else if ((c > 127) && (c < 2048)) {
20775
				utftext += String.fromCharCode((c >> 6) | 192);
20776
				utftext += String.fromCharCode((c & 63) | 128);
20777
			} else {
20778
				utftext += String.fromCharCode((c >> 12) | 224);
20779
				utftext += String.fromCharCode(((c >> 6) & 63) | 128);
20780
				utftext += String.fromCharCode((c & 63) | 128);
20781
			}
20782
		}
20783
		return utftext;
20784
	}
20785

    
20786
	// Public method for encoding
20787
	return {
20788
		encode: (typeof btoa == 'function') ? function (input) {
20789
			return btoa(utf8Encode(input));
20790
		}
20791
		 : function (input) {
20792
			var output = "";
20793
			var chr1,
20794
			chr2,
20795
			chr3,
20796
			enc1,
20797
			enc2,
20798
			enc3,
20799
			enc4;
20800
			var i = 0;
20801
			input = utf8Encode(input);
20802
			while (i < input.length) {
20803
				chr1 = input.charCodeAt(i++);
20804
				chr2 = input.charCodeAt(i++);
20805
				chr3 = input.charCodeAt(i++);
20806
				enc1 = chr1 >> 2;
20807
				enc2 = ((chr1 & 3) << 4) | (chr2 >> 4);
20808
				enc3 = ((chr2 & 15) << 2) | (chr3 >> 6);
20809
				enc4 = chr3 & 63;
20810
				if (isNaN(chr2)) {
20811
					enc3 = enc4 = 64;
20812
				} else if (isNaN(chr3)) {
20813
					enc4 = 64;
20814
				}
20815
				output = output +
20816
					keyStr.charAt(enc1) + keyStr.charAt(enc2) +
20817
					keyStr.charAt(enc3) + keyStr.charAt(enc4);
20818
			}
20819
			return output;
20820
		}
20821
	};
20822
})();
20823
Ext.define('MyApp.view.override.Grid', {
20824
	override: 'Ext.grid.GridPanel',
20825
	requires: 'Ext.form.action.StandardSubmit',
20826

    
20827
	/*
20828
	Kick off process
20829
	 */
20830

    
20831
	downloadExcelXml: function (includeHidden, name) {
20832

    
20833
		if (!name)
20834
			title = this.name;
20835

    
20836
		var vExportContent = this.getExcelXml(includeHidden, title);
20837

    
20838
		var location = 'data:application/vnd.ms-excel;base64,' + Base64.encode(vExportContent);
20839

    
20840
		/*
20841
		dynamically create and anchor tag to force download with suggested filename
20842
		note: download attribute is Google Chrome specific
20843
		 */
20844

    
20845
		if (Ext.isChrome) {
20846
			var gridEl = this.getEl();
20847

    
20848
			var el = Ext.DomHelper.append(gridEl, {
20849
					tag: "a",
20850
					download: title + "-" + Ext.Date.format(new Date(), 'Y-m-d Hi') + '.xls',
20851
					href: location
20852
				});
20853

    
20854
			el.click();
20855

    
20856
			Ext.fly(el).destroy();
20857

    
20858
		} else {
20859

    
20860
			var form = this.down('form#uploadForm');
20861
			if (form) {
20862
				form.destroy();
20863
			}
20864
			form = this.add({
20865
					xtype: 'form',
20866
					itemId: 'uploadForm',
20867
					hidden: true,
20868
					standardSubmit: true,
20869
					url: 'http://webapps.figleaf.com/dataservices/Excel.cfc?method=echo&mimetype=application/vnd.ms-excel&filename=' + escape(title + ".xls"),
20870
					items: [{
20871
							xtype: 'hiddenfield',
20872
							name: 'data',
20873
							value: vExportContent
20874
						}
20875
					]
20876
				});
20877

    
20878
			form.getForm().submit();
20879

    
20880
		}
20881
	},
20882

    
20883
	/*
20884

    
20885
	Welcome to XML Hell
20886
	See: http://msdn.microsoft.com/en-us/library/office/aa140066(v=office.10).aspx
20887
	for more details
20888

    
20889
	 */
20890
	getExcelXml: function (includeHidden, title) {
20891

    
20892
		var theTitle = title || this.title;
20893

    
20894
		var worksheet = this.createWorksheet(includeHidden, theTitle);
20895
		var totalWidth = this.columnManager.columns.length;
20896

    
20897
		return ''.concat(
20898
			'<?xml version="1.0"?>',
20899
			'<Workbook xmlns="urn:schemas-microsoft-com:office:spreadsheet" xmlns:o="urn:schemas-microsoft-com:office:office" xmlns:x="urn:schemas-microsoft-com:office:excel" xmlns:ss="urn:schemas-microsoft-com:office:spreadsheet" xmlns:html="http://www.w3.org/TR/REC-html40">',
20900
			'<DocumentProperties xmlns="urn:schemas-microsoft-com:office:office"><Title>' + theTitle + '</Title></DocumentProperties>',
20901
			'<OfficeDocumentSettings xmlns="urn:schemas-microsoft-com:office:office"><AllowPNG/></OfficeDocumentSettings>',
20902
			'<ExcelWorkbook xmlns="urn:schemas-microsoft-com:office:excel">',
20903
			'<WindowHeight>' + worksheet.height + '</WindowHeight>',
20904
			'<WindowWidth>' + worksheet.width + '</WindowWidth>',
20905
			'<ProtectStructure>False</ProtectStructure>',
20906
			'<ProtectWindows>False</ProtectWindows>',
20907
			'</ExcelWorkbook>',
20908

    
20909
			'<Styles>',
20910

    
20911
			'<Style ss:ID="Default" ss:Name="Normal">',
20912
			'<Alignment ss:Vertical="Bottom"/>',
20913
			'<Borders/>',
20914
			'<Font ss:FontName="Calibri" x:Family="Swiss" ss:Size="12" ss:Color="#000000"/>',
20915
			'<Interior/>',
20916
			'<NumberFormat/>',
20917
			'<Protection/>',
20918
			'</Style>',
20919

    
20920
			'<Style ss:ID="title">',
20921
			'<Borders />',
20922
			'<Font ss:Bold="1" ss:Size="18" />',
20923
			'<Alignment ss:Horizontal="Center" ss:Vertical="Center" ss:WrapText="1" />',
20924
			'<NumberFormat ss:Format="@" />',
20925
			'</Style>',
20926

    
20927
			'<Style ss:ID="headercell">',
20928
			'<Font ss:Bold="1" ss:Size="10" />',
20929
			'<Alignment ss:Horizontal="Center" ss:WrapText="1" />',
20930
			'<Interior ss:Color="#A3C9F1" ss:Pattern="Solid" />',
20931
			'</Style>',
20932

    
20933
			'<Style ss:ID="even">',
20934
			'<Interior ss:Color="#CCFFFF" ss:Pattern="Solid" />',
20935
			'</Style>',
20936

    
20937
			'<Style ss:ID="evendate" ss:Parent="even">',
20938
			'<NumberFormat ss:Format="yyyy-mm-dd" />',
20939
			'</Style>',
20940

    
20941
			'<Style ss:ID="evenint" ss:Parent="even">',
20942
			'<Numberformat ss:Format="0" />',
20943
			'</Style>',
20944

    
20945
			'<Style ss:ID="evenfloat" ss:Parent="even">',
20946
			'<Numberformat ss:Format="0.00" />',
20947
			'</Style>',
20948

    
20949
			'<Style ss:ID="odd">',
20950
			'<Interior ss:Color="#CCCCFF" ss:Pattern="Solid" />',
20951
			'</Style>',
20952

    
20953
			'<Style ss:ID="groupSeparator">',
20954
			'<Interior ss:Color="#D3D3D3" ss:Pattern="Solid" />',
20955
			'</Style>',
20956

    
20957
			'<Style ss:ID="odddate" ss:Parent="odd">',
20958
			'<NumberFormat ss:Format="yyyy-mm-dd" />',
20959
			'</Style>',
20960

    
20961
			'<Style ss:ID="oddint" ss:Parent="odd">',
20962
			'<NumberFormat Format="0" />',
20963
			'</Style>',
20964

    
20965
			'<Style ss:ID="oddfloat" ss:Parent="odd">',
20966
			'<NumberFormat Format="0.00" />',
20967
			'</Style>',
20968

    
20969
			'</Styles>',
20970
			worksheet.xml,
20971
			'</Workbook>');
20972
	},
20973

    
20974
	/*
20975

    
20976
	Support function to return field info from store based on fieldname
20977

    
20978
	 */
20979

    
20980
	getModelField: function (fieldName) {
20981

    
20982
		var fields = this.store.model.getFields();
20983
		for (var i = 0; i < fields.length; i++) {
20984
			if (fields[i].name === fieldName) {
20985
				return fields[i];
20986
			}
20987
		}
20988
	},
20989

    
20990
	/*
20991

    
20992
	Convert store into Excel Worksheet
20993

    
20994
	 */
20995
	generateEmptyGroupRow: function (dataIndex, value, cellTypes, includeHidden) {
20996

    
20997
		var cm = this.columnManager.columns;
20998
		var colCount = cm.length;
20999
		var rowTpl = '<Row ss:AutoFitHeight="0"><Cell ss:StyleID="groupSeparator" ss:MergeAcross="{0}"><Data ss:Type="String"><html:b>{1}</html:b></Data></Cell></Row>';
21000
		var visibleCols = 0;
21001

    
21002
		// rowXml += '<Cell ss:StyleID="groupSeparator">'
21003

    
21004
		for (var j = 0; j < colCount; j++) {
21005
			if (cm[j].xtype != 'actioncolumn' && (cm[j].dataIndex != '') && (includeHidden || !cm[j].hidden)) {
21006
				// rowXml += '<Cell ss:StyleID="groupSeparator"/>';
21007
				visibleCols++;
21008
			}
21009
		}
21010

    
21011
		// rowXml += "</Row>";
21012

    
21013
		return Ext.String.format(rowTpl, visibleCols - 1, value);
21014
	},
21015

    
21016
	createWorksheet: function (includeHidden, theTitle) {
21017
		// Calculate cell data types and extra class names which affect formatting
21018
		var cellType = [];
21019
		var cellTypeClass = [];
21020
		var cm = this.columnManager.columns;
21021

    
21022
		var totalWidthInPixels = 0;
21023
		var colXml = '';
21024
		var headerXml = '';
21025
		var visibleColumnCountReduction = 0;
21026
		var colCount = cm.length;
21027
		for (var i = 0; i < colCount; i++) {
21028
			if (cm[i].xtype != 'actioncolumn' && (cm[i].dataIndex != '') && (includeHidden || !cm[i].hidden)) {
21029
				var w = cm[i].getEl().getWidth();
21030
				totalWidthInPixels += w;
21031

    
21032
				if (cm[i].text === "") {
21033
					cellType.push("None");
21034
					cellTypeClass.push("");
21035
					++visibleColumnCountReduction;
21036
				} else {
21037
					colXml += '<Column ss:AutoFitWidth="1" ss:Width="' + w + '" />';
21038
					headerXml += '<Cell ss:StyleID="headercell">' +
21039
					'<Data ss:Type="String">' + cm[i].dataIndex + '</Data>' +
21040
					'<NamedCell ss:Name="Print_Titles"></NamedCell></Cell>';
21041

    
21042
					var fld = this.getModelField(cm[i].dataIndex);
21043
					switch (fld.type.type) {
21044
					case "int":
21045
						cellType.push("Number");
21046
						cellTypeClass.push("int");
21047
						break;
21048
					case "float":
21049
						cellType.push("Number");
21050
						cellTypeClass.push("float");
21051
						break;
21052

    
21053
					case "bool":
21054

    
21055
					case "boolean":
21056
						cellType.push("String");
21057
						cellTypeClass.push("");
21058
						break;
21059
					case "date":
21060
						cellType.push("DateTime");
21061
						cellTypeClass.push("date");
21062
						break;
21063
					default:
21064
						cellType.push("String");
21065
						cellTypeClass.push("");
21066
						break;
21067
					}
21068
				}
21069
			}
21070
		}
21071
		var visibleColumnCount = cellType.length - visibleColumnCountReduction;
21072

    
21073
		var result = {
21074
			height: 9000,
21075
			width: Math.floor(totalWidthInPixels * 30) + 50
21076
		};
21077

    
21078
		// Generate worksheet header details.
21079

    
21080
		// determine number of rows
21081
		var numGridRows = this.store.getCount() + 2;
21082
		if (!Ext.isEmpty(this.store.groupField)) {
21083
			numGridRows = numGridRows + this.store.getGroups().length;
21084
		}
21085

    
21086
		// create header for worksheet
21087
		var t = ''.concat(
21088
				'<Worksheet ss:Name="' + theTitle + '">',
21089

    
21090
				'<Names>',
21091
				'<NamedRange ss:Name="Print_Titles" ss:RefersTo="=\'' + theTitle + '\'!R1:R2">',
21092
				'</NamedRange></Names>',
21093

    
21094
				'<Table ss:ExpandedColumnCount="' + (visibleColumnCount + 2),
21095
				'" ss:ExpandedRowCount="' + numGridRows + '" x:FullColumns="1" x:FullRows="1" ss:DefaultColumnWidth="65" ss:DefaultRowHeight="15">',
21096
				colXml,
21097
				'<Row ss:AutoFitHeight="1">',
21098
				headerXml +
21099
				'</Row>');
21100

    
21101
		// Generate the data rows from the data in the Store
21102
		var groupVal = "";
21103
		var groupField = "";
21104

    
21105
		for (var i = 0, it = this.store.data.items, l = it.length; i < l; i++) {
21106

    
21107
			if (!Ext.isEmpty(groupField)) {
21108
				if (groupVal != this.store.getAt(i).get(groupField)) {
21109
					groupVal = this.store.getAt(i).get(groupField);
21110
					t += this.generateEmptyGroupRow(groupField, groupVal, cellType, includeHidden);
21111
				}
21112
			}
21113
			t += '<Row>';
21114
			var cellClass = (i & 1) ? 'odd' : 'even';
21115
			r = it[i].data;
21116
			var k = 0;
21117
			for (var j = 0; j < colCount; j++) {
21118
				if (cm[j].xtype != 'actioncolumn' && (cm[j].dataIndex != '') && (includeHidden || !cm[j].hidden)) {
21119
					var v = r[cm[j].dataIndex];
21120
					if (cellType[k] !== "None") {
21121
						t += '<Cell ss:StyleID="' + cellClass + cellTypeClass[k] + '"><Data ss:Type="' + cellType[k] + '">';
21122
						if (cellType[k] == 'DateTime') {
21123
							t += Ext.Date.format(v, 'Y-m-d');
21124
						} else {
21125
							t += v;
21126
						}
21127
						t += '</Data></Cell>';
21128
					}
21129
					k++;
21130
				}
21131
			}
21132
			t += '</Row>';
21133
		}
21134

    
21135
		result.xml = t.concat(
21136
				'</Table>',
21137
				'<WorksheetOptions xmlns="urn:schemas-microsoft-com:office:excel">',
21138
				'<PageLayoutZoom>0</PageLayoutZoom>',
21139
				'<Selected/>',
21140
				'<Panes>',
21141
				'<Pane>',
21142
				'<Number>3</Number>',
21143
				'<ActiveRow>2</ActiveRow>',
21144
				'</Pane>',
21145
				'</Panes>',
21146
				'<ProtectObjects>False</ProtectObjects>',
21147
				'<ProtectScenarios>False</ProtectScenarios>',
21148
				'</WorksheetOptions>',
21149
				'</Worksheet>');
21150
		return result;
21151
	}
21152
});
21153

    
21154
/*Add Midi For Grid Mass Posting Filo*/
21155
Ext.define('MinovaUtil.MinovaES.MinovaEditAbleGridList', {
21156
    extend: 'Ext.form.Panel',
21157
    alias: ['widget.MinovaEditAbleGridList', 'widget.Minovaeditablegridlist', 'widget.minovaeditablegridlist'],
21158
    requires: [
21159
		'Ext.grid.plugin.CellEditing',
21160
		'Ext.grid.RowNumberer',
21161
		'Ext.grid.Panel',
21162
    ],
21163

    
21164
    //renderTo: 'panel-extjs',
21165
    anchor: '100%',
21166
    tableName: undefined,
21167
    hideButton: undefined,
21168
    multiSelect: undefined,
21169
    initComponent: function () {
21170
        var me = this;
21171
        var isLookup = me.isLookup;
21172
        var hide_ = false;
21173
        var widthLock = 250;
21174
        var checkSelection = '';
21175

    
21176
        if (me.hideButton == true) {
21177
            hide_ = true;
21178
        }
21179
        if (me.multiSelect) {
21180
            locking = false;
21181
            checkSelection = 'checkboxmodel';
21182
            widthLock = 40;
21183
        }
21184
        var tableName = me.tableName;
21185
        var cols = [];
21186
        var fieldStore = [];
21187
        var _url = 'GetAllField';
21188
        var hasil = null;
21189
        var height = me.height;
21190
        var storeID = 'store' + me.tableName;
21191
        var gridName = 'grid' + me.name;
21192
        if (me.storeName) {
21193
            storeID = me.storeName;
21194
        }
21195
        var LangID = MinovaUtil.GetLangID();
21196
        var parameter = "LangID='" + LangID + "',TableName='" + me.tableName + "'"
21197
        Ext.Ajax.request({
21198
            async: false,
21199
            method: 'POST',
21200
            url: '/UserControl/GetStore',
21201
            params: {
21202
                tableName: 'PDSBS0007',
21203
                param: parameter
21204
            },
21205
            success: function (response) {
21206
                var results = Ext.decode(response.responseText);
21207
                hasil = results.data;
21208
            }
21209
        });
21210
        cols.push({
21211
            xtype: 'rownumberer'
21212
        });
21213
        var addData = 'var data={';
21214
        if (hasil.length > 0) {
21215
            Ext.each(hasil, function (rec) {
21216
                fieldStore.push(rec.FieldName);
21217
                if (rec.FieldName != 'Sequence') {
21218
                    addData = addData + rec.FieldName + ":" + "'',";
21219
                }
21220

    
21221
                var null_ = null;
21222
                var ReadOnly_ = false;
21223
                if (rec.IsPrimaryKey == true) {
21224
                    null_ = false;
21225
                }
21226
                if (rec.IsRequired == true) {
21227
                    null_ = false;
21228
                } else {
21229
                    null_ = true;
21230
                }
21231
                if (rec.ReadOnly == '1') {
21232
                    ReadOnly_ = true;
21233
                }
21234
                var Hidden_ = false;
21235
                if (rec.ReadOnly == '1') {
21236
                    ReadOnly_ = true;
21237
                }
21238

    
21239
                if (rec.IsHidden == '1' || rec.Sequence == '' || rec.Sequence == '0' || rec.ColumnNo == '' || rec.GridView == '') {
21240
                    Hidden_ = true;
21241
                    null_ = true;
21242
                }
21243

    
21244
                if (rec.GridView == 1) {
21245
                    switch (rec.FormatRef) {
21246
                        case "date":
21247
                            cols.push({
21248
                                xtype: 'minovadatecolumn',
21249
                                hidden: Hidden_,
21250
                                text: rec.HeaderTitle,
21251
                                dataIndex: rec.FieldName,
21252
                                filter: {
21253
                                    itemDefaults: {
21254
                                        emptyText: 'Search for...',
21255

    
21256
                                    }
21257
                                },
21258
                                editor: {
21259
                                    allowBlank: null_,
21260
                                    xtype: 'datefield',
21261
                                    hideMode: 'visibility',
21262
                                    readOnly: ReadOnly_,
21263
                                    id: tableName + rec.FieldName,
21264
                                    fieldGrid: rec.FieldName,
21265
                                    nameTable: rec.TableName,
21266
                                }
21267
                            });
21268
                            break
21269
                        case "amount":
21270
                            cols.push({
21271
                                xtype: 'minovacurrancycolumn',
21272
                                //renderer: Ext.util.Format.numberRenderer("0,0"),
21273
                                text: rec.HeaderTitle,
21274
                                align: 'right',
21275
                                dataIndex: rec.FieldName,
21276
                                hidden: Hidden_,
21277
                                filter: {
21278
                                    itemDefaults: {
21279
                                        emptyText: 'Search for...'
21280
                                    }
21281
                                },
21282
                                editor: {
21283
                                    allowBlank: null_,
21284
                                    xtype: 'minovacurrencyfield',
21285
                                    //renderer: Ext.util.Format.numberRenderer("0,0"),
21286
                                    //vtype: 'validateDecimal',
21287
                                    readOnly: ReadOnly_,
21288
                                    id: tableName + rec.FieldName,
21289
                                    nameTable: rec.TableName,
21290
                                    fieldGrid: rec.FieldName,
21291
                                    fieldStyle: 'text-align:right;',
21292
                                    value: '0',
21293

    
21294
                                }
21295
                            });
21296
                            break
21297
                        case "time":
21298
                            var DefaultValue = rec.DefaultValue;
21299
                            if (DefaultValue == '') {
21300
                                defaultValue = '00:00';
21301
                            }
21302
                            cols.push({
21303
                                //xtype: 'minovatimecolumn',
21304
                                xtype: 'timefield',
21305
                                format: 'H:i',
21306
                                submitFormat: 'Hi',
21307
                                text: rec.HeaderTitle,
21308
                                dataIndex: rec.FieldName,
21309
                                hidden: Hidden_,
21310
                                //renderer: Ext.util.Format.dateRenderer('G:i'),
21311
                                filter: {
21312
                                    itemDefaults: {
21313
                                        emptyText: 'Search for...'
21314
                                    }
21315
                                },
21316
                                editor: {
21317
                                    allowBlank: null_,
21318
                                    xtype: 'timefield',
21319
                                    readOnly: ReadOnly_,
21320
                                    id: tableName + rec.FieldName,
21321
                                    format: 'H:i',
21322
                                    submitFormat: 'Hi',
21323
                                    increment: 5,
21324
                                    value: DefaultValue,
21325
                                    anchor: '100%',
21326
                                    listeners: {}
21327
                                    //renderer: Ext.util.Format.dateRenderer('G:i'),
21328
                                }
21329
                            });
21330
                            break
21331
                            //case "datetime":
21332
                            //    if (rec.DataRef != 'CREATEDT' && rec.DataRef != 'CHANGEDT') {
21333
                            //        cols.push({
21334
                            //            xtype: 'minovadatetimecolumn',
21335
                            //            text: rec.HeaderTitle,
21336
                            //            dataIndex: rec.FieldName,
21337
                            //            filter: {
21338
                            //                itemDefaults: {
21339
                            //                    emptyText: 'Search for...'
21340
                            //                }
21341
                            //            },
21342
                            //            editor: {
21343
                            //                allowBlank: null_,
21344
                            //                xtype: 'textfield',
21345
                            //            }
21346
                            //        });
21347
                            //    }
21348
                            //    break
21349
                        default:
21350
                            if (rec.DataRef == 'CREATEBY' || rec.DataRef == 'CHANGEBY' || rec.DataRef == 'CREATEDT' || rec.DataRef == 'CHANGEDT') {
21351
                                cols.push({
21352
                                    text: rec.HeaderTitle,
21353
                                    dataIndex: rec.FieldName,
21354
                                    width: 100,
21355
                                    filter: {
21356
                                        type: 'string',
21357
                                        itemDefaults: {
21358
                                            emptyText: 'Search for...'
21359
                                        }
21360
                                    }
21361
                                });
21362
                            } else if (rec.SearchType == '0') {
21363
                                var valueField = null;
21364
                                var displayValue = null;
21365
                                var TableRef = undefined;
21366
                                if (rec.TableRef != '') {
21367
                                    TableRef = rec.TableRef;
21368

    
21369
                                    Ext.Ajax.request({
21370
                                        async: false,
21371
                                        method: 'POST',
21372
                                        url: '/UserControl/GetStore',
21373
                                        params: {
21374
                                            tableName: 'SDATATABLEFIELD',
21375
                                            param: 'TableName[equal]' + rec.TableRef
21376
                                        },
21377
                                        success: function (response) {
21378
                                            var results = Ext.decode(response.responseText);
21379
                                            data_ = results.data;
21380
                                            if (data_ != undefined) {
21381
                                                valueField_ = $.grep(data_, function (r) {
21382
                                                    return r.ValueField == '1'
21383
                                                });
21384
                                                valueField = valueField_[0].FieldName
21385
                                                displayValue_ = $.grep(data_, function (r) {
21386
                                                    return r.DisplayValue == '1'
21387
                                                });
21388
                                                displayValue = displayValue_[0].FieldName
21389
                                            }
21390
                                        }
21391
                                    });
21392

    
21393
                                    //create Store
21394
                                    Ext.create('Ext.data.Store', {
21395
                                        storeId: 'store_' + me.tableName + rec.FieldName,
21396
                                        autoLoad: true,
21397
                                        proxy: {
21398
                                            method: 'POST',
21399
                                            type: 'ajax',
21400
                                            url: '/UserControl/GetStoreAuth',
21401
                                            extraParams: {
21402
                                                tableName: TableRef,
21403
                                                param: rec.ParamCombo,
21404
                                                menuId: MinovaUtil.GetMenuID()
21405
                                            },
21406
                                            reader: {
21407
                                                type: 'json',
21408
                                                root: 'data',
21409
                                                totalProperty: 'data[0].TotalCount'
21410
                                            }
21411
                                        }
21412
                                    });
21413
                                } else if (rec.FixedValue != '') {
21414
                                    var storeData = [];
21415
                                    var str = rec.FixedValue;
21416
                                    var hasil = str.split('||');
21417
                                    hasil.forEach(function (h) {
21418
                                        store_ = h.split('=')
21419
                                        storeData.push({
21420
                                            code: store_[0],
21421
                                            desc: store_[1],
21422

    
21423
                                        });
21424
                                    });
21425

    
21426
                                    valueField = 'code';
21427
                                    displayValue = 'desc';
21428

    
21429
                                    Ext.create('Ext.data.Store', {
21430
                                        storeId: 'store_' + me.tableName + rec.FieldName,
21431
                                        autoLoad: true,
21432
                                        data: storeData
21433
                                    })
21434
                                }
21435

    
21436
                                cols.push({
21437
                                    xtype: 'minovacombocolumn',
21438
                                    hidden: Hidden_,
21439
                                    text: rec.HeaderTitle,
21440
                                    dataIndex: rec.FieldName,
21441
                                    valueField: valueField,
21442
                                    displayField: displayValue,
21443
                                    store: 'store_' + me.tableName + rec.FieldName,
21444
                                    editor: {
21445
                                        allowBlank: null_,
21446
                                        xtype: 'combobox',
21447
                                        readOnly: ReadOnly_,
21448
                                        id: tableName + rec.FieldName,
21449
                                        nameTable: rec.TableName,
21450
                                        fieldGrid: rec.FieldName,
21451
                                        valueField: valueField,
21452
                                        displayField: displayValue,
21453
                                        vtype: 'validateCombobox',
21454
                                        store: 'store_' + me.tableName + rec.FieldName,
21455
                                    },
21456
                                    filter: {
21457
                                        type: 'list',
21458
                                        itemDefaults: {
21459
                                            emptyText: 'Search for...'
21460
                                        }
21461
                                    }
21462
                                });
21463

    
21464
                            } else if (rec.SearchType == '5') {							
21465
                                var valueField = null;
21466
                                var displayValue = null;
21467
                                var AdditionaldisplayValue = null;
21468
                                var TableRef = undefined;
21469
                                if (rec.TableRef != '') {
21470
                                    TableRef = rec.TableRef;
21471
                                    Ext.Ajax.request({
21472
                                        async: false,
21473
                                        method: 'POST',
21474
                                        url: '/UserControl/GetStore',
21475
                                        params: {
21476
                                            tableName: 'SDATATABLEFIELD',
21477
                                            param: 'TableName[equal]' + rec.TableRef
21478
                                        },
21479
                                        success: function (response) {
21480
                                            var results = Ext.decode(response.responseText);
21481
                                            data_ = results.data;
21482
                                            if (data_ != undefined) {
21483
                                                valueField_ = $.grep(data_, function (r) {
21484
                                                    return r.ValueField == '1'
21485
                                                });
21486
                                                if (valueField_.length > 0) {
21487
                                                    valueField = valueField_[0].FieldName
21488
                                                }
21489

    
21490
                                                displayValue_ = $.grep(data_, function (r) {
21491
                                                    return r.DisplayValue == '1' || r.DisplayValue == '2'
21492
                                                });
21493
                                                if (displayValue_.length > 0) {
21494
                                                    displayValue = displayValue_[0].FieldName;
21495
                                                }
21496
                                                if (displayValue_.length >= 2) {
21497
                                                    AdditionaldisplayValue = displayValue_[1].FieldName
21498
                                                }
21499
                                            }
21500
                                        }
21501
                                    });
21502
                                }
21503
                                Ext.create('Ext.data.Store', {
21504
                                    storeId: 'store_' + me.tableName + rec.FieldName,
21505
                                    autoLoad: true,
21506
                                    proxy: {
21507
                                        method: 'POST',
21508
                                        type: 'ajax',
21509
                                        url: '/UserControl/GetStoreAuth',
21510
                                        extraParams: {
21511
                                            tableName: TableRef,
21512
                                            param: rec.ParamCombo,
21513
                                            menuId: MinovaUtil.GetMenuID()
21514
                                        },
21515
                                        reader: {
21516
                                            type: 'json',
21517
                                            root: 'data',
21518
                                            totalProperty: 'data[0].TotalCount'
21519
                                        }
21520
                                    }
21521
                                });
21522
                                cols.push({
21523
                                    xtype : 'minovacombocolumn',
21524
                                    hidden: Hidden_,
21525
                                    text: rec.HeaderTitle,
21526
                                    dataIndex: rec.FieldName,
21527
                                    valueField : valueField,
21528
                                    displayField : displayValue,
21529
                                    store : 'store_' + me.tableName + rec.FieldName,
21530
                                    tpl: Ext.create('Ext.XTemplate',
21531
                                            '<ul class="x-list-plain"><tpl for=".">',
21532
                                            '<li role="option" class="x-boundlist-item">{' + AdditionaldisplayValue + '} - {' + displayValue + '}</li>',
21533
                                            '</tpl></ul>'),
21534
                                    displayTpl: Ext.create('Ext.XTemplate',
21535
                                        '<tpl for=".">',
21536
                                        '{' + AdditionaldisplayValue + '} - {' + displayValue + '}',
21537
                                        '</tpl>'),
21538
                                    editor: {
21539
                                        allowBlank: null_,
21540
                                        xtype: 'combobox',
21541
                                        readOnly: ReadOnly_,
21542
                                        id: rec.TableName + rec.FieldName,
21543
                                        nameTable: rec.TableName,
21544
                                        fieldGrid: rec.FieldName,
21545
                                        valueField: valueField,
21546
                                        displayField: displayValue,
21547
                                        store: 'store_' + me.tableName + rec.FieldName,
21548
                                        value: rec.DefaultValue,
21549
                                        tpl: Ext.create('Ext.XTemplate',
21550
                                            '<ul class="x-list-plain"><tpl for=".">',
21551
                                            '<li role="option" class="x-boundlist-item">{' + AdditionaldisplayValue + '} - {' + displayValue + '}</li>',
21552
                                            '</tpl></ul>'),
21553
                                        displayTpl: Ext.create('Ext.XTemplate',
21554
                                            '<tpl for=".">',
21555
                                            '{' + AdditionaldisplayValue + '} - {' + displayValue + '}',
21556
                                            '</tpl>')
21557
                                    },
21558
                                    renderer: function (value) {
21559
                                        var store = Ext.data.StoreManager.lookup('store_' + me.tableName + rec.FieldName);
21560
                                        var index = store.find(valueField, value);
21561
                                        var val = "";
21562
                                        if (index != -1) {
21563
                                            var rc = store.getAt(index);
21564
                                            //val = rc.get(displayValue);
21565
                                            val = rc.get(AdditionaldisplayValue) + ' - ' + rc.get(displayValue);
21566
                                        } else {
21567
                                            val = value;
21568
                                        }
21569
                                        return val;
21570
                                    },
21571
                                    filter: {
21572
                                        type: 'list',
21573
                                        itemDefaults: {
21574
                                            emptyText: 'Search for...'
21575
                                        }
21576
                                    }
21577
                                });
21578
                            } else if (rec.SearchType == '2') {
21579
                                var triger = (rec.TriggerCombo).split('$');
21580
                                var targetField_ = triger[0];
21581
                                var fieldValue_ = triger[1];
21582
                                cols.push({
21583
                                    text: rec.HeaderTitle,
21584
                                    hidden: Hidden_,
21585
                                    dataIndex: rec.FieldName,
21586
                                    filter: {
21587
                                        itemDefaults: {
21588
                                            emptyText: 'Search for...'
21589
                                        }
21590
                                    },
21591
                                    editor: {
21592
                                        allowBlank: null_,
21593
                                        xtype: 'minovalookupgrid',
21594
                                        readOnly: ReadOnly_,
21595
                                        isGrid: true,
21596
                                        fieldTarget: targetField_,
21597
                                        fieldValue: fieldValue_,
21598
                                        isGrid: true,
21599
                                        id: tableName + rec.FieldName,
21600
                                        tableName: rec.TableRef, //name tabel yang jadi ref-nya
21601
                                        triggerCls: 'x-form-search-trigger',
21602
                                        vtype: 'alphanum', // disable space
21603
                                        nameTable: rec.TableName,
21604
                                        fieldGrid: rec.FieldName,
21605
                                        LookupFunction: rec.LookupFunction,
21606
                                        listeners: {
21607
                                            change: function (val) {
21608
                                                var custumFunc = rec.SelectFunction;
21609
                                                if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
21610
                                                    Ext.Ajax.request({
21611
                                                        async: false,
21612
                                                        method: 'POST',
21613
                                                        url: '/UserControl/GetStore',
21614
                                                        params: {
21615
                                                            tableName: 'PCMFUNC',
21616
                                                            param: 'FuncName[equal]' + rec.custumFunc + ',Active[=]1'
21617
                                                        },
21618
                                                        success: function (response) {
21619
                                                            var results = Ext.decode(response.responseText);
21620
                                                            data_ = results.data[0];
21621
                                                            if (data_ != undefined) {
21622
                                                                custumFunc = data_.FunctionCode;
21623
                                                            }
21624
                                                        }
21625
                                                    });
21626
                                                }
21627
                                                if (custumFunc) {
21628
                                                    eval(custumFunc)
21629
                                                }
21630
                                            }
21631
                                        }
21632
                                    }
21633
                                });
21634
                            } else if (rec.SearchType == '3') {
21635
                                cols.push({
21636
                                    text: rec.HeaderTitle,
21637
                                    hidden: Hidden_,
21638
                                    dataIndex: rec.FieldName,
21639
                                    filter: {
21640
                                        itemDefaults: {
21641
                                            emptyText: 'Search for...'
21642
                                        }
21643
                                    },
21644
                                    editor: {
21645
                                        allowBlank: null_,
21646
                                        // xtype: 'minovalookuptreePopup',
21647
                                        xtype: 'MinovaLookupTree',
21648
                                        readOnly: ReadOnly_,
21649
                                        id: tableName + rec.FieldName,
21650
                                        tableName: rec.TableRef, //name tabel yang jadi ref-nya
21651
                                        triggerCls: 'x-form-search-trigger',
21652
                                        vtype: 'alphanum', // disable space
21653
                                        treeSructure: rec.SearchFunction, //'O-O-P',
21654
                                        objClassValue: rec.ParamCombo, //'O',
21655
                                        nameTable: rec.TableName,
21656
                                        fieldGrid: rec.FieldName,
21657
                                        listeners: {
21658
                                            change: function (val) {
21659
                                                var custumFunc = rec.SelectFunction;
21660
                                                if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
21661
                                                    Ext.Ajax.request({
21662
                                                        async: false,
21663
                                                        method: 'POST',
21664
                                                        url: '/UserControl/GetStore',
21665
                                                        params: {
21666
                                                            tableName: 'PCMFUNC',
21667
                                                            param: 'FuncName[equal]' + rec.custumFunc + ',Active[=]1'
21668
                                                        },
21669
                                                        success: function (response) {
21670
                                                            var results = Ext.decode(response.responseText);
21671
                                                            data_ = results.data[0];
21672
                                                            if (data_ != undefined) {
21673
                                                                custumFunc = data_.FunctionCode;
21674
                                                            }
21675
                                                        }
21676
                                                    });
21677
                                                }
21678
                                                if (custumFunc) {
21679
                                                    eval(custumFunc)
21680
                                                }
21681
                                            }
21682
                                        }
21683
                                    }
21684
                                });
21685
                            } else if (rec.SearchType != '0' && rec.SearchType != '1' && rec.SearchType != '3' && (rec.FieldName == 'EmployeeID' || rec.FieldName == 'ApplicantID' || rec.FieldName == 'EmployeeIDFrom' || rec.FieldName == 'EmployeeIDTo') && isLookup != true) {
21686
                                var triger = (rec.TriggerCombo).split('&');
21687
                                var targetField_ = triger[0];
21688
                                var fieldValue_ = triger[0];
21689
                                cols.push({
21690
                                    text: rec.HeaderTitle,
21691
                                    hidden: Hidden_,
21692
                                    dataIndex: rec.FieldName,
21693
                                    filter: {
21694
                                        itemDefaults: {
21695
                                            emptyText: 'Search for...'
21696
                                        }
21697
                                    },
21698
                                    editor: {
21699
                                        allowBlank: null_,
21700
                                        xtype: 'lookupemployee',
21701
                                        readOnly: ReadOnly_,
21702
                                        isGrid: true,
21703
                                        fieldTarget: targetField_,
21704
                                        fieldValue: fieldValue_,
21705
                                        isGrid: true,
21706
                                        id: tableName + rec.FieldName,
21707
                                        tableName: rec.TableRef, //name tabel yang jadi ref-nya
21708
                                        triggerCls: 'x-form-search-trigger',
21709
                                        vtype: 'alphanum', // disable space
21710
                                        nameTable: rec.TableName,
21711
                                        fieldGrid: rec.FieldName,
21712
                                        listeners: {
21713
                                            change: function (val) {
21714
                                                var custumFunc = rec.SelectFunction;
21715
                                                if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
21716
                                                    Ext.Ajax.request({
21717
                                                        async: false,
21718
                                                        method: 'POST',
21719
                                                        url: '/UserControl/GetStore',
21720
                                                        params: {
21721
                                                            tableName: 'PCMFUNC',
21722
                                                            param: 'FuncName[equal]' + rec.custumFunc + ',Active[=]1'
21723
                                                        },
21724
                                                        success: function (response) {
21725
                                                            var results = Ext.decode(response.responseText);
21726
                                                            data_ = results.data[0];
21727
                                                            if (data_ != undefined) {
21728
                                                                custumFunc = data_.FunctionCode;
21729
                                                            }
21730
                                                        }
21731
                                                    });
21732
                                                }
21733
                                                if (custumFunc) {
21734
                                                    eval(custumFunc)
21735
                                                }
21736
                                            }
21737
                                        }
21738
                                    }
21739
                                });
21740
                            } else if (rec.SearchType == '4' && isLookup != true) {
21741
                                cols.push({
21742

    
21743
                                    text: rec.HeaderTitle,
21744
                                    hidden: Hidden_,
21745
                                    dataIndex: rec.FieldName,
21746
                                    filter: {
21747
                                        itemDefaults: {
21748
                                            emptyText: 'Search for...'
21749
                                        }
21750
                                    },
21751
                                    editor: {
21752
                                        allowBlank: null_,
21753
                                        xtype: 'lookupemployee',
21754
                                        readOnly: ReadOnly_,
21755
                                        isGrid: true,
21756
                                        fieldTarget: targetField_,
21757
                                        fieldValue: fieldValue_,
21758
                                        isGrid: true,
21759
                                        id: tableName + rec.FieldName,
21760
                                        tableName: rec.TableRef, //name tabel yang jadi ref-nya
21761
                                        triggerCls: 'x-form-search-trigger',
21762
                                        vtype: 'alphanum', // disable space
21763
                                        nameTable: rec.TableName,
21764
                                        fieldGrid: rec.FieldName,
21765
                                        listeners: {
21766
                                            change: function (val) {
21767
                                                var custumFunc = rec.SelectFunction;
21768
                                                if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
21769
                                                    Ext.Ajax.request({
21770
                                                        async: false,
21771
                                                        method: 'POST',
21772
                                                        url: '/UserControl/GetStore',
21773
                                                        params: {
21774
                                                            tableName: 'PCMFUNC',
21775
                                                            param: 'FuncName[equal]' + rec.custumFunc + ',Active[=]1'
21776
                                                        },
21777
                                                        success: function (response) {
21778
                                                            var results = Ext.decode(response.responseText);
21779
                                                            data_ = results.data[0];
21780
                                                            if (data_ != undefined) {
21781
                                                                custumFunc = data_.FunctionCode;
21782
                                                            }
21783
                                                        }
21784
                                                    });
21785
                                                }
21786
                                                if (custumFunc) {
21787
                                                    eval(custumFunc)
21788
                                                }
21789
                                            }
21790
                                        }
21791
                                    }
21792
                                });
21793
                            } else {
21794
                                if (rec.FieldDataType == 3) { //add by taufan
21795
                                    cols.push({
21796
                                        text: rec.HeaderTitle,
21797
                                        hidden: Hidden_,
21798
                                        dataIndex: rec.FieldName,
21799
                                        filter: {
21800
                                            itemDefaults: {
21801
                                                emptyText: 'Search for...'
21802
                                            }
21803
                                        },
21804
                                        editor: {
21805
                                            allowBlank: null_,
21806
                                            xtype: 'textfield',
21807
                                            readOnly: ReadOnly_,
21808
                                            id: tableName + rec.FieldName,
21809
                                            nameTable: rec.TableName,
21810
                                            fieldGrid: rec.FieldName,
21811
                                            vtype: 'validateDecimal',
21812
                                            maxLength: rec.Length,
21813
                                            precision: rec.Prec,
21814
                                            fieldStyle: 'text-align:right;',
21815
                                            listeners: {
21816
                                                change: function (val) {
21817
                                                    var custumFunc = null;
21818
                                                    Ext.Ajax.request({
21819
                                                        async: false,
21820
                                                        method: 'POST',
21821
                                                        url: '/UserControl/GetStore',
21822
                                                        params: {
21823
                                                            tableName: 'SDATATABLEFIELD',
21824
                                                            param: 'FieldName[equal]' + rec.FieldName + ',TableName[equal]' + me.tableName
21825
                                                        },
21826
                                                        success: function (response) {
21827
                                                            var results = Ext.decode(response.responseText);
21828
                                                            data_ = results.data[0];
21829
                                                            if (data_ != undefined) {
21830
                                                                custumFunc = data_.SelectFunction;
21831
                                                                //console.log(data_)
21832
                                                            }
21833
                                                        }
21834
                                                    });
21835

    
21836
                                                    if (custumFunc) {
21837
                                                        eval(custumFunc)
21838
                                                    }
21839
                                                }
21840
                                            }
21841
                                        }
21842
                                    });
21843
                                } else {
21844
                                    cols.push({
21845
                                        text: rec.HeaderTitle,
21846
                                        hidden: Hidden_,
21847
                                        dataIndex: rec.FieldName,
21848
                                        filter: {
21849
                                            itemDefaults: {
21850
                                                emptyText: 'Search for...'
21851
                                            }
21852
                                        },
21853
                                        editor: {
21854
                                            allowBlank: null_,
21855
                                            xtype: 'textfield',
21856
                                            readOnly: ReadOnly_,
21857
                                            id: tableName + rec.FieldName,
21858
                                            nameTable: rec.TableName,
21859
                                            fieldGrid: rec.FieldName,
21860
                                            listeners: {
21861
                                                change: function (val) {
21862
                                                    var custumFunc = null;
21863
                                                    Ext.Ajax.request({
21864
                                                        async: false,
21865
                                                        method: 'POST',
21866
                                                        url: '/UserControl/GetStore',
21867
                                                        params: {
21868
                                                            tableName: 'SDATATABLEFIELD',
21869
                                                            param: 'FieldName[equal]' + rec.FieldName + ',TableName[equal]' + me.tableName
21870
                                                        },
21871
                                                        success: function (response) {
21872
                                                            var results = Ext.decode(response.responseText);
21873
                                                            data_ = results.data[0];
21874
                                                            if (data_ != undefined) {
21875
                                                                custumFunc = data_.SelectFunction;
21876
                                                                //console.log(data_)
21877
                                                            }
21878
                                                        }
21879
                                                    });
21880

    
21881
                                                    if (custumFunc) {
21882
                                                        eval(custumFunc)
21883
                                                    }
21884
                                                }
21885
                                            }
21886
                                        }
21887
                                    });
21888
                                }
21889
                            }
21890

    
21891
                            break
21892

    
21893
                    }
21894
                } else {
21895
                    cols.push({
21896
                        text: rec.HeaderTitle,
21897
                        hidden: Hidden_,
21898
                        dataIndex: rec.FieldName,
21899
                        hidden: true,
21900
                        editor: {
21901
                            allowBlank: true,
21902
                            xtype: 'textfield',
21903
                            readOnly: ReadOnly_,
21904
                            id: tableName + rec.FieldName,
21905
                            nameTable: rec.TableName,
21906
                            fieldGrid: rec.FieldName,
21907
                        },
21908
                        filter: {
21909
                            itemDefaults: {
21910
                                emptyText: 'Search for...'
21911
                            }
21912
                        }
21913
                    });
21914
                }
21915
            });
21916

    
21917
        };
21918
        addData = addData + "}";
21919
        Ext.applyIf(me, {
21920
            items: [{
21921
                xtype: 'grid',
21922
                id: gridName,
21923
                name: gridName,
21924
                height: height,
21925
                viewConfig: {
21926
                    emptyText: 'No Data Display',
21927
                    deferEmptyText: false,
21928
                    //Add Nana For Autosize Column Mode
21929
                    listeners: {
21930
                        refresh: function (dataview) {
21931
                            Ext.each(dataview.panel.columns, function (column) {
21932
                                //if (column.autoSizeColumn == false)
21933
                                //	column.autoSizeColumn = true;
21934
                                column.autoSize();
21935
                                //dataview.store.reload();
21936
                            })
21937
                        }
21938
                    },
21939
                    render: function (comp) {
21940
                        comp.getStore().reload();
21941
                        console.log(comp);
21942
                    }
21943
                },
21944
                //store: 'gridStore',
21945
                store: Ext.create('Ext.data.Store', {
21946
                    storeId: storeID,
21947
                    fields: fieldStore,
21948
                    proxy: {
21949
                        method: 'POST',
21950
                        type: 'ajax',
21951
                        url: '',
21952
                        reader: {
21953
                            type: 'json',
21954
                            root: 'data'
21955
                        }
21956
                    }
21957
                }),
21958
                dockedItems: [{
21959
                    xtype: 'toolbar',
21960
                    items: [{
21961
                        text: 'Add',
21962
                        hidden: hide_,
21963
                        name: tableName + 'Add',
21964
                        iconCls: 'fa-plus-circle',
21965
                        style: 'font-family: FontAwesome',
21966
                        handler: function () {
21967
                            var store = Ext.StoreMgr.lookup(storeID)
21968
                            idx = store.getCount();
21969
                            var action = getParam('action');
21970
                            var data = '';
21971
                            var Sequence = 0;
21972
                            if (idx == 0) {
21973
                                Sequence = 1;
21974
                            } else {
21975
                                Sequence = 1 + idx;
21976
                            }
21977
                            //data = {
21978
                            //    Sequence: Sequence
21979
                            //};
21980

    
21981
                            var seq = 'Sequence';
21982
                            var SequenceValue = Sequence;
21983
                            eval(addData);
21984
                            data[seq] = SequenceValue;
21985

    
21986
                            store.insert(idx, data);
21987
                        }
21988

    
21989
                    }, {
21990
                        text: 'Delete',
21991
                        hidden: hide_,
21992
                        name: tableName + 'DeleteText',
21993
                        iconCls: 'fa-trash-o',
21994
                        style: 'font-family: FontAwesome',
21995
                        //disabled: true
21996
                        handler: function () {
21997
                            var me = this,
21998
                            store = Ext.StoreMgr.lookup(storeID)
21999

    
22000
                            var grid = Ext.getCmp(gridName);
22001

    
22002
                            Ext.MessageBox.show({
22003
                                title: 'Remove tab',
22004
                                msg: "This will remove. Do you want to continue?",
22005
                                buttons: Ext.MessageBox.YESNO,
22006
                                fn: function (choice) {
22007
                                    console.log(choice);
22008
                                    if (choice === 'yes') {
22009
                                        var selection = grid.getView().getSelectionModel().getSelection()[0];
22010
                                        if (selection) {
22011
                                            store.remove(selection);
22012
                                        }
22013
                                    }
22014
                                    //delete panel.pendingClose;
22015
                                }
22016
                            });
22017
                        }
22018

    
22019
                    }
22020
                    ]
22021
                }
22022
                ],
22023
                columns: cols,
22024
                selType: checkSelection,
22025
                //selType: 'rowmodel',
22026
                plugins: {
22027
                    ptype: 'rowediting',
22028
                    pluginId: 'rowEditing',
22029
                    clicksToEdit: 1,
22030
                    listeners: {
22031
                        //edit: 'onGridEditorEdit'
22032
                    }
22033
                }
22034
            }, ]
22035

    
22036
        });
22037

    
22038
        me.callParent(arguments);
22039
    }
22040
});
22041

    
22042
/*Add by Midi ( Tab List Mass Posting ERP DocType AR)*/
22043
Ext.define('MinovaUtil.MinovaES.MinovaTabListDocTransAR', {
22044
	extend: 'Ext.tab.Panel',
22045
	alias: ['widget.doctablistAR'],
22046
	transType: undefined,
22047
	docType: undefined,
22048
	docNo: undefined,
22049
	langId: undefined,
22050
	param: undefined,
22051
	layout: 'fit',
22052
	name: 'panelTabAR',
22053
	id: 'mainTabAR',
22054
	action: undefined,
22055
	initComponent: function () {
22056
		var me = this;
22057
		var documentType = me.docType;
22058
		var transactionType = me.transType;
22059
		var hasil = null;
22060
		var _items = [];
22061
		Ext.Ajax.request({
22062
			async: false,
22063
			method: 'POST',
22064
			url: '/UserControl/GetStore',
22065
			params: {
22066
				tableName: 'PCMBSTRANSLIST',
22067
				param: 'TransType[=]' + me.transType
22068
			},
22069
			success: function (response) {
22070
				var results = Ext.decode(response.responseText);
22071
				hasil = results.data;
22072
			}
22073
		});
22074
		hasil = hasil.sort(MinovaUtil.SortBy("Sequence"));
22075
		if (hasil.length > 0) {
22076
			Ext.each(hasil, function (rec) {
22077
				if (rec.LayoutType == "L004") { // L004=Custom
22078
					var pnl = Ext.create(rec.CustomLayout, {
22079
							title: rec.Title,
22080
							tableName: rec.TableName,
22081
							height: 400,
22082
							name: 'panelTab' + rec.TableName,
22083
							tbl: rec.TableName,
22084
							layoutType: rec.LayoutType
22085
						});
22086
					_items.push(pnl)
22087
				} else if (rec.LayoutType == "L002" || rec.LayoutType == "L003") {
22088
					_items.push({
22089
						xtype: 'panel',
22090
						title: rec.Title,
22091
						name: 'panelTab' + rec.TableName,
22092
						tbl: rec.TableName,
22093
						layoutType: rec.LayoutType,
22094
						items: [{
22095
								xtype: 'docgrid',
22096
								height: 400,
22097
								tableName: rec.TableName,
22098
								docType: me.docType,
22099
								transType: me.transType,
22100
								storename: 'store' + rec.TableName,
22101
								pagesize: 25,
22102
								name: 'GRID' + rec.TableName,
22103
								margin: '0 0 10 0',
22104
								autoLoad: false,
22105
								tbar: [{
22106
										xtype: 'button',
22107
										text: 'Action',
22108
										name: 'actionGrid' + rec.TableName,
22109
										menu: [{
22110
												text: 'Add',
22111
												name: 'add' + rec.TableName,
22112
												tbl: rec.TableName,
22113
												style: 'font-family: FontAwesome',
22114
												iconCls: 'fa-plus-circle',
22115
												handler: function () {
22116
													var frmDisplay = Ext.ComponentQuery.query('[name=DISPLAY' + rec.TableName + ']')[0];
22117
													var frmForm = Ext.ComponentQuery.query('[name=FORM' + rec.TableName + ']')[0];
22118
													var grdPanel = Ext.ComponentQuery.query('[name=GRID' + rec.TableName + ']')[0];
22119
													frmDisplay.reset();
22120
													frmForm.reset();
22121
													frmDisplay.setHidden(true);
22122
													frmForm.setHidden(false);
22123
													grdPanel.setHidden(true);
22124
													action = "0";
22125
												}
22126
											}, {
22127
												text: 'Delete',
22128
												name: 'delete' + rec.TableName,
22129
												tbl: rec.TableName,
22130
												iconCls: 'fa-trash-o',
22131
												style: 'font-family: FontAwesome',
22132
												handler: function () {
22133
													var me = this;
22134
													var store = Ext.StoreMgr.lookup('store' + rec.TableName);
22135
													var grdPanel = Ext.ComponentQuery.query('[name=GRID' + rec.TableName + ']')[0];
22136
													Ext.MessageBox.show({
22137
														title: 'Remove tab',
22138
														msg: "This will remove. Do you want to continue?",
22139
														buttons: Ext.MessageBox.YESNO,
22140
														fn: function (choice) {
22141
															console.log(choice);
22142
															if (choice === 'yes') {
22143
																var selection = grdPanel.getView().getSelectionModel().getSelection()[0];
22144
																if (selection) {
22145
																	store.remove(selection);
22146
																}
22147
															}
22148
														}
22149
													});
22150
												}
22151
											}
22152
										]
22153
									}, {
22154
										xtype: 'tbfill'
22155
									}, {
22156
										text: 'Clear Filters',
22157
										tooltip: 'Clear all filters',
22158
										name: 'clearbtn',
22159
										handler: function () {}
22160
									}
22161
								],
22162
								dockedItems: [{
22163
										xtype: 'pagingtoolbar',
22164
										store: 'store' + rec.TableName,
22165
										dock: 'bottom',
22166
										pageSize: me.pagesize,
22167
										displayInfo: true
22168
									}
22169
								],
22170
								listeners: {
22171
									'itemdblclick': function (me, record, item, index, e, eOpts) {
22172
										var frmDisplay = Ext.ComponentQuery.query('[name=DISPLAY' + rec.TableName + ']')[0];
22173
										var frmForm = Ext.ComponentQuery.query('[name=FORM' + rec.TableName + ']')[0];
22174
										var grdPanel = Ext.ComponentQuery.query('[name=GRID' + rec.TableName + ']')[0];
22175
										frmDisplay.reset();
22176
										frmForm.reset();
22177
										frmDisplay.getForm().setValues(record.data);
22178
										frmForm.getForm().setValues(record.data);
22179
										frmDisplay.setHidden(false);
22180
										frmForm.setHidden(true);
22181
										grdPanel.setHidden(true);
22182
										action = "1";
22183
									}
22184
								}
22185
							}, {
22186
								xtype: 'minovadocform',
22187
								name: 'DISPLAY' + rec.TableName,
22188
								id: 'DISPLAY' + rec.TableName,
22189
								itemId: 'DISPLAY' + rec.TableName,
22190
								tableName: rec.TableName,
22191
								docType: me.docType,
22192
								transType: me.transType,
22193
								isDisplay: true,
22194
								hidden: true,
22195
								buttons: [{
22196
										text: 'Edit',
22197
										name: 'editDISPLAY' + rec.TableName,
22198
										handler: function () {
22199
											var frmDisplay = Ext.ComponentQuery.query('[name=DISPLAY' + rec.TableName + ']')[0];
22200
											var frmForm = Ext.ComponentQuery.query('[name=FORM' + rec.TableName + ']')[0];
22201
											var grdPanel = Ext.ComponentQuery.query('[name=GRID' + rec.TableName + ']')[0];
22202
											frmDisplay.setHidden(true);
22203
											frmForm.setHidden(false);
22204
											grdPanel.setHidden(true);
22205
										}
22206
									}, {
22207
										text: 'Cancel',
22208
										name: 'cancelDISPLAY' + rec.TableName,
22209
										handler: function () {
22210
											var frmDisplay = Ext.ComponentQuery.query('[name=DISPLAY' + rec.TableName + ']')[0];
22211
											var frmForm = Ext.ComponentQuery.query('[name=FORM' + rec.TableName + ']')[0];
22212
											var grdPanel = Ext.ComponentQuery.query('[name=GRID' + rec.TableName + ']')[0];
22213
											frmDisplay.setHidden(true);
22214
											frmForm.setHidden(true);
22215
											grdPanel.setHidden(false);
22216
											grdPanel.getStore().reload();
22217
										}
22218
									}
22219
								]
22220
							}, {
22221
								xtype: 'minovadocform',
22222
								name: 'FORM' + rec.TableName,
22223
								id: 'FORM' + rec.TableName,
22224
								itemId: 'FORM' + rec.TableName,
22225
								tableName: rec.TableName,
22226
								docType: me.docType,
22227
								transType: me.transType,
22228
								isDisplay: false,
22229
								hidden: true,
22230
								buttons: [{
22231
										text: 'Submit',
22232
										name: 'submitFORM' + rec.TableName,
22233
										handler: function () {
22234
											var frmDisplay = Ext.ComponentQuery.query('[name=DISPLAY' + rec.TableName + ']')[0];
22235
											var frmForm = Ext.ComponentQuery.query('[name=FORM' + rec.TableName + ']')[0];
22236
											var grdPanel = Ext.ComponentQuery.query('[name=GRID' + rec.TableName + ']')[0];
22237
											var frm = frmForm.getForm();
22238
											if (frm.isValid()) {
22239
												var table = rec.TableName;
22240
												var data = frmForm.getValues();
22241
												var token = MinovaUtil.SESSIONS.Token;
22242
												var str = grdPanel.getStore();
22243
												var idx = str.getCount();
22244
												str.insert(idx, data);
22245
												frmDisplay.setHidden(true);
22246
												frmForm.setHidden(true);
22247
												grdPanel.setHidden(false);
22248
											}
22249
										}
22250
									}, {
22251
										text: 'Cancel',
22252
										name: 'cancelFORM' + rec.TableName,
22253
										handler: function () {
22254
											MinovaMessage('Message', '000011', '', 'C', function (respone) {
22255
												if (respone == "yes") {
22256
													var frmDisplay = Ext.ComponentQuery.query('[name=DISPLAY' + rec.TableName + ']')[0];
22257
													var frmForm = Ext.ComponentQuery.query('[name=FORM' + rec.TableName + ']')[0];
22258
													var grdPanel = Ext.ComponentQuery.query('[name=GRID' + rec.TableName + ']')[0];
22259
													frmDisplay.setHidden(true);
22260
													frmForm.setHidden(true);
22261
													grdPanel.setHidden(false);
22262
												}
22263
											});
22264
										}
22265
									}
22266
								]
22267
							}
22268
						]
22269
					});
22270
				} else if (rec.LayoutType == "L005") { // Grid View Only
22271
					_items.push({
22272
						xtype: 'panel',
22273
						title: rec.Title,
22274
						name: 'panelTab' + rec.TableName,
22275
						tbl: rec.TableName,
22276
						layoutType: rec.LayoutType,
22277
						items: [{
22278
								xtype: 'docgrid',
22279
								height: 400,
22280
								tableName: rec.TableName,
22281
								docType: me.docType,
22282
								transType: me.transType,
22283
								storename: 'store' + rec.TableName,
22284
								pagesize: 25,
22285
								name: 'GRID' + rec.TableName,
22286
								margin: '0 0 10 0',
22287
								autoLoad: false,
22288
								tbar: [{
22289
										xtype: 'tbfill'
22290
									}, {
22291
										text: 'Clear Filters',
22292
										tooltip: 'Clear all filters',
22293
										name: 'clearbtn',
22294
										handler: function () {}
22295
									}
22296
								],
22297
								dockedItems: [{
22298
										xtype: 'pagingtoolbar',
22299
										store: 'store' + rec.TableName,
22300
										dock: 'bottom',
22301
										pageSize: me.pagesize,
22302
										displayInfo: true
22303
									}
22304
								]
22305
							}
22306
						]
22307
					});
22308
				} else if (rec.LayoutType == "L006") {
22309
					_items.push({
22310
						xtype: 'panel',
22311
						title: rec.Title,
22312
						name: 'panelTab' + rec.TableName,
22313
						tbl: rec.TableName,
22314
						layoutType: rec.LayoutType,
22315
						items: [{
22316
								xtype: 'docgridcelledit',
22317
								name: 'CELLGRID' + rec.TableName,
22318
								tableName: rec.TableName,
22319
								docType: me.docType,
22320
								transType: me.transType,
22321
								docNo: me.docNo,
22322
								height: 400,
22323
								hideButton: false,
22324
								margin: '0 0 10 0'
22325
							}
22326
						]
22327
					});
22328
				} else if (rec.LayoutType == "L007") {
22329
					_items.push({
22330
						xtype: 'panel',
22331
						title: rec.Title,
22332
						name: 'panelTab' + rec.TableName,
22333
						tbl: rec.TableName,
22334
						layoutType: rec.LayoutType,
22335
						items: [{
22336
								xtype: 'docgridcelleditsum',
22337
								name: 'CELLGRID' + rec.TableName,
22338
								tableName: rec.TableName,
22339
								docType: me.docType,
22340
								transType: me.transType,
22341
								docNo: me.docNo,
22342
								height: 400,
22343
								hideButton: false,
22344
								margin: '0 0 10 0'
22345
							}, {
22346
								xtype: 'summarydocform',
22347
								name: 'SUM' + rec.TableName,
22348
								id: 'SUM' + rec.TableName,
22349
								itemId: 'SUM' + rec.TableName,
22350
								tableName: rec.TableName,
22351
								docType: me.docType,
22352
								transType: me.transType,
22353
							}
22354
						]
22355
					});
22356
				} else { // L001=Default Form Only
22357
					_items.push({
22358
						xtype: 'panel',
22359
						title: rec.LabelName,
22360
						name: 'panelTab' + rec.TableName,
22361
						tbl: rec.TableName,
22362
						layoutType: rec.LayoutType,
22363
						items: [{
22364
								xtype: 'minovadocform',
22365
								name: 'DISPLAY' + rec.TableName,
22366
								id: 'DISPLAY' + rec.TableName,
22367
								itemId: 'DISPLAY' + rec.TableName,
22368
								tableName: rec.TableName,
22369
								docType: me.docType,
22370
								transType: me.transType,
22371
								isDisplay: true,
22372
								hidden: false,
22373
								buttons: [{
22374
										text: 'Edit',
22375
										name: 'editDISPLAY' + rec.TableName,
22376
										iconCls: 'fa-edit',
22377
										style: 'font-family: FontAwesome',
22378
										handler: function () {
22379
											var frmDisplay = Ext.ComponentQuery.query('[name=DISPLAY' + rec.TableName + ']')[0];
22380
											var frmForm = Ext.ComponentQuery.query('[name=FORM' + rec.TableName + ']')[0];
22381
											frmDisplay.setHidden(true);
22382
											frmForm.setHidden(false);
22383
											action = "1";
22384
										}
22385
									}, {
22386
										text: 'Cancel',
22387
										name: 'cancelDISPLAY' + rec.TableName,
22388
										iconCls: 'fa-reply',
22389
										style: 'font-family: FontAwesome',
22390
										hidden: true
22391
									}
22392
								]
22393
							}, {
22394
								xtype: 'minovadocform',
22395
								name: 'FORM' + rec.TableName,
22396
								id: 'FORM' + rec.TableName,
22397
								itemId: 'FORM' + rec.TableName,
22398
								tableName: rec.TableName,
22399
								docType: me.docType,
22400
								transType: me.transType,
22401
								isDisplay: false,
22402
								hidden: true,
22403
								buttons: [{
22404
										text: 'Save',
22405
										name: 'saveDISPLAY' + rec.TableName,
22406
										iconCls: 'fa-save',
22407
										style: 'font-family: FontAwesome',
22408
										handler: function () {
22409
											var frmDisplay = Ext.ComponentQuery.query('[name=DISPLAY' + rec.TableName + ']')[0];
22410
											var frmForm = Ext.ComponentQuery.query('[name=FORM' + rec.TableName + ']')[0];
22411
											var headerDisplay = Ext.ComponentQuery.query('[name=MainHeaderMDLogistic]')[0];
22412
											var frm = frmForm.getForm();
22413
											if (frm.isValid()) {
22414
												var table = rec.TableName;
22415
												var data = Ext.encode(frmForm.getValues());
22416
												var token = MinovaUtil.SESSIONS.Token;
22417
												var params = {
22418
													apiController: 'api/Devt',
22419
													methodName: 'SaveTableMaster',
22420
													parameter: 'tableName=' + table + '&data=' + data + '&action=' + action + '&token=' + token
22421
												};
22422
												MinovaAjaxPost('/ApiService/Api/', params, function (xhr) {
22423
													var result = Ext.decode(xhr.responseText);
22424
													var r = Ext.decode(result.data);
22425
													if (r.success) {
22426
														headerDisplay.mask("Loading...");
22427
														var idNo = r.data;
22428
														frmForm.getForm().findField("DocNo").setValue(idNo);
22429
														frmDisplay.getForm().setValues(frmForm.getValues());
22430
														headerDisplay.getForm().setValues(frmForm.getValues());
22431
														frmDisplay.setHidden(false);
22432
														frmForm.setHidden(true);
22433
														MinovaMessage('Not Null', '000006', '', 'S');
22434
														headerDisplay.unmask();
22435
													} else {
22436
														MinovaMessage(' Not Null ', ' 000005 ', r.message.text, 'E');
22437
													}
22438
												});
22439
											}
22440
										}
22441
									}, {
22442
										text: 'Delete',
22443
										name: 'deleteDISPLAY' + rec.TableName,
22444
										iconCls: 'fa-trash-o',
22445
										style: 'font-family: FontAwesome',
22446
										handler: function () {}
22447
									}, {
22448
										text: 'Cancel',
22449
										name: 'cancelDISPLAY' + rec.TableName,
22450
										iconCls: 'fa-reply',
22451
										style: 'font-family: FontAwesome',
22452
										handler: function () {
22453
											MinovaMessage('Message', '000011', '', 'C', function (respone) {
22454
												if (respone == "yes") {
22455
													var frmDisplay = Ext.ComponentQuery.query('[name=DISPLAY' + rec.TableName + ']')[0];
22456
													var frmForm = Ext.ComponentQuery.query('[name=FORM' + rec.TableName + ']')[0];
22457
													frmDisplay.setHidden(false);
22458
													frmForm.setHidden(true);
22459
												}
22460
											});
22461
										}
22462
									}
22463
								]
22464
							}
22465
						]
22466
					});
22467
				}
22468
			});
22469
		}
22470
		Ext.applyIf(me, {
22471
			items: _items
22472
		});
22473
		me.callParent(arguments);
22474
	}
22475
});
22476

    
22477
/*Add by YN ( Tab List for PA on Top)*/
22478
Ext.define('MinovaUtil.MinovaES.MinovaHeaderMDNew', {
22479
    extend: 'Ext.form.Panel',
22480
    alias: ['widget.MinovaHeadermdNew', 'widget.MinovaHeaderMDNew'],
22481
    allTableName: undefined,
22482
    param: undefined,
22483
    //frame: true,
22484
    resizable: true,
22485
    autoScroll: true,
22486
    minHeight: 20,
22487
    layout: 'column',
22488
    name: 'HeaderMD',
22489
    getAllTableName: function () {
22490
        return this.allTableName;
22491
    },
22492
    setAllTableName: function (value) {
22493
        var me = this;
22494
        me.allTableName = value;
22495
        return me;
22496
    },
22497
    listeners: {
22498
        afterrender: function (me) {
22499
            var nowDate = MinovaUtil.GetNowDate()
22500
            var allTbl = me.getAllTableName();
22501
            //alert(allTbl);
22502
            var splitTable = allTbl.split(',')
22503
            splitTable.forEach(function (tbl) {
22504
                // console.log(tbl);
22505
                //set values form
22506
                var nowDate = MinovaUtil.GetNowDate();
22507
                parameter = null;
22508
                if (me.isEmployee == true) {
22509
                    parameter = 'StartDate[<=]' + nowDate + ',EndDate[>=]' + nowDate + ',EmployeeID[=]' + getParam("EmployeeID")
22510
                } else {
22511
                    parameter = 'StartDate[<=]' + nowDate + ',EndDate[>=]' + nowDate + ',EmployeeID[=]' + getParam("ApplicantID")
22512
                }
22513
                Ext.Ajax.request({
22514
                    method: 'POST',
22515
                    //async: false,
22516
                    url: '/UserControl/GetStore',
22517
                    params: {
22518
                        tableName: tbl,
22519
                        param: parameter
22520
                    },
22521
                    success: function (response) {
22522
                        var results = Ext.decode(response.responseText);
22523
                        hasil = results.data;
22524
                        if (hasil.length > 0) {
22525
                            me.getForm().setValues(hasil[0]);
22526

    
22527
                            //console.log(me)
22528
                        }
22529

    
22530
                    }
22531
                });
22532
            });
22533

    
22534
            //setTimeout(function () {
22535
            //    // var me_ = Ext.ComponentQuery.query('[name=Header]')[0];
22536
            //    // me_.setTitle(me_.getTitle() + ' - ' + Ext.ComponentQuery.query('[name=FullName]')[0].getValue());
22537
            //}, 100);
22538

    
22539
        },
22540

    
22541
    },
22542

    
22543
    initComponent: function () {
22544
        var me = this;
22545
        var col1 = [];
22546
        var col2 = [];
22547
        var hasil = null;
22548
        //get moduletype
22549
        //var ModuleType = 'PA';
22550
        //var ModuleType = MinovaUtil.GetModuleType()
22551
        //get Lang
22552
        var LangId = localStorage.LangId;
22553
        var allTable = null;
22554
        var tbl = null;
22555
        var tblTemp = null;
22556
        var nowDate = MinovaUtil.GetNowDate();
22557
        //var Photo_ = 'nophoto.gif';
22558
        var Photo = 'nophoto.gif';
22559
        tableName = null;
22560
        parameter = null;
22561
        // get Photo
22562
        //hamid200916
22563
        if (me.isEmployee == true) {
22564
            tableName = 'PHRPA0001';
22565
            parameter = 'StartDate[<=]' + nowDate + ',EndDate[>=]' + nowDate + ',EmployeeID[=]' + getParam("EmployeeID");
22566
        } else {
22567
            tableName = 'PHRRC0001';
22568
            parameter = 'StartDate[<=]' + nowDate + ',EndDate[>=]' + nowDate + ',EmployeeID[=]' + getParam("ApplicantID")
22569
        }
22570
        Ext.Ajax.request({
22571
            method: 'POST',
22572
            async: false,
22573
            url: '/UserControl/GetStore',
22574
            params: {
22575
                tableName: tableName,
22576
                param: parameter
22577
            },
22578
            success: function (response) {
22579
                var results = Ext.decode(response.responseText);
22580
                hasil = results.data;
22581
                if (hasil.length > 0) {
22582
                    dataPhoto = hasil[0].Picture
22583
                    if (dataPhoto != "") {
22584
                        Photo = dataPhoto;
22585
                    }
22586
                }
22587

    
22588
            }
22589
        });
22590

    
22591
        var hasil = undefined;
22592
        Ext.Ajax.request({
22593
            async: false,
22594
            method: 'POST',
22595
            url: '/UserControl/GetStore',
22596
            params: {
22597
                tableName: 'PDSBS0009',
22598
                param: 'MenuID[=]' + MinovaUtil.GetMenuID() + ',LangId[=]' + LangId
22599
            },
22600
            success: function (response) {
22601
                hasil = Ext.decode(response.responseText).data;
22602

    
22603
            }
22604
        });
22605

    
22606
        //sorting results
22607
        hasil = hasil.sort(MinovaUtil.SortBy("Sequence"));
22608
        if (hasil.length > 0) {
22609
            Ext.each(hasil, function (rec) {
22610
                tblTemp = rec.TableName;
22611
                if (tbl != tblTemp) {
22612
                    tbl = tblTemp;
22613
                    if (allTable == null) {
22614
                        allTable = tbl
22615
                    } else {
22616
                        allTable = allTable + ',' + tbl
22617
                    }
22618

    
22619
                }
22620
                // build form
22621
                if (rec.TableRef != '') {
22622
                    valueField = null;
22623
                    displayValue = null;
22624
                    Ext.Ajax.request({
22625
                        async: false,
22626
                        method: 'POST',
22627
                        url: '/UserControl/GetStore',
22628
                        params: {
22629
                            tableName: 'SDATATABLEFIELD',
22630
                            param: 'TableName[equal]' + rec.TableRef
22631
                        },
22632
                        success: function (response) {
22633
                            var results = Ext.decode(response.responseText);
22634
                            data_ = results.data;
22635
                            if (data_ != undefined) {
22636
                                valueField_ = $.grep(data_, function (r) {
22637
                                    return r.ValueField == '1'
22638
                                });
22639
                                if (valueField_.length > 0) {
22640
                                    valueField = valueField_[0].FieldName
22641
                                }
22642

    
22643
                                displayValue_ = $.grep(data_, function (r) {
22644
                                    return r.DisplayValue == '1'
22645
                                });
22646
                                if (displayValue_.length > 0) {
22647
                                    displayValue = displayValue_[0].FieldName
22648
                                }
22649
                            }
22650
                        }
22651
                    });
22652

    
22653
                    formfield = new Ext.form.Display({
22654
                        fieldLabel: rec.ScreenCaption,
22655
                        name: rec.FieldName,
22656
                        //value: rec.DefaultValue,
22657
                        padding: 0,
22658
                        labelCls: 'label-minova',
22659
                        labelWidth: 150,
22660
                        anchor: '80%',
22661
                        store: Ext.create('Ext.data.Store', {
22662
                            storeId: 'storeDisplay' + rec.FieldName,
22663
                            //autoLoad: true,
22664
                            proxy: {
22665
                                method: 'POST',
22666
                                type: 'ajax',
22667
                                extraParams: {
22668
                                    tableName: rec.TableRef,
22669
                                    param: ''
22670
                                },
22671
                                reader: {
22672
                                    type: 'json',
22673
                                    root: 'data',
22674
                                    totalProperty: 'data[0].TotalCount'
22675
                                }
22676
                            }
22677
                        }),
22678
                        listeners: {
22679
                            afterrender: function (f) {
22680
                                var store = Ext.StoreMgr.lookup('storeDisplay' + rec.FieldName);
22681
                                var ParamCombo = rec.ParamCombo;
22682
                                var param = '';
22683
                                //if (ParamCombo != '') {
22684
                                if ((rec.TableRef).toLowerCase() == 'phrom0001') {
22685
                                    var splitParam = ParamCombo.split(']');
22686
                                    switch (rec.FieldName) {
22687
                                        case 'Position':
22688
                                            ParamCombo = 'P'
22689
                                            break;
22690
                                        case 'CostCenter':
22691
                                            ParamCombo = 'CC'
22692
                                            break;
22693
                                        case 'Organization':
22694
                                            ParamCombo = 'O'
22695
                                            break;
22696
                                        case 'Job':
22697
                                            ParamCombo = 'J'
22698
                                            break;
22699
                                    }
22700
                                    //if (splitParam.length == 1) {
22701
                                    param = 'StartDate[<=]' + MinovaUtil.GetNowDate() + 'EndDate[>=]' + MinovaUtil.GetNowDate() + ',ObjectClass[=]' + ParamCombo
22702
                                    //} else {
22703
                                    //    param = ParamCombo;
22704
                                    //}
22705
                                }
22706
                                //}
22707
                                Ext.Ajax.request({
22708
                                    method: 'POST',
22709
                                    async: false,
22710
                                    url: '/UserControl/GetStore',
22711
                                    params: {
22712
                                        tableName: rec.TableRef,
22713
                                        param: param
22714
                                    },
22715
                                    success: function (response) {
22716
                                        var results = Ext.decode(response.responseText);
22717

    
22718
                                        //dt = results.data;
22719
                                        store.loadData(results.data);
22720

    
22721
                                    }
22722
                                });
22723
                            },
22724
                            change: function (f) {
22725
                                //alert(this.valueField, value);
22726
                                var display = this.displayField;
22727
                                var value = this.getValue();
22728
                                var st = f.store
22729
                                var r = st.findRecord(f.valueField, f.value)
22730
                                if (r != null) {
22731
                                    f.setRawValue(r.get(f.displayField))
22732
                                } else {
22733
                                    f.setRawValue(f.value);
22734

    
22735
                                }
22736
                            }
22737
                        },
22738
                        queryMode: 'local',
22739
                        displayField: displayValue,
22740
                        valueField: valueField,
22741
                    });
22742
                }
22743
                else {
22744
                    formfield = new Ext.form.Display({
22745
                        fieldLabel: rec.ScreenCaption,
22746
                        name: rec.FieldName,
22747
                        labelCls: 'label-minova',
22748
                        labelWidth: 150,
22749
                        //value: rec.DefaultValue,
22750
                        padding: 0,
22751
                        anchor: '80%'
22752
                    });
22753
                }
22754
                if (isDesk) {
22755
                    if (rec.Column == 1) {
22756
                        col1.push(formfield);
22757
                    } else {
22758
                        col2.push(formfield);
22759
                    }
22760
                } else {
22761
                    col1.push(formfield);
22762
                }
22763

    
22764
            });
22765
            //set allTable
22766
            this.setAllTableName(allTable);
22767
        }
22768

    
22769
        Ext.applyIf(me, {
22770
            items: [
22771
                {
22772
                    width: 150,
22773
                    //margin: '10 5 3 30',
22774
                    margin: '5 0 0 30',
22775
                    height: 130,
22776
                    items: [
22777
                        {
22778
                            xtype: 'image',
22779
                            id: 'imageusermd',
22780
                            name: 'imageusermd',
22781
                            width: 120,
22782
                            height: 120,
22783
                            padding: 5,
22784
                            border: true,
22785
                            src: '/Devt/GetFileData?FileName=' + Photo + '&download=false',
22786
                        }
22787
                    ]
22788
                },
22789
                {
22790
                    bodyPadding: 0,
22791
                    width: 350,
22792
                    margin: '15 0 0 30', //margin: '10 5 3 30',
22793
                    items: col1
22794
                },
22795
                {
22796
                    bodyPadding: 0,
22797
                    //width: 350,
22798
                    margin: '15 0 0 30', //margin: '10 5 3 30',
22799
                    items: col2
22800
                }
22801
            ],
22802
        });
22803

    
22804
        me.callParent(arguments);
22805

    
22806
    }
22807
});
22808

    
22809
//panelTab->panelTab+TableName->GRID+TableName | DISPLAY+TableName | FORM+TableName 
22810
Ext.define('MinovaUtil.MinovaES.MinovaTabListMDNew', {
22811
    extend: 'Ext.tab.Panel',
22812
    alias: ['widget.MinovaTabListMDNew'],
22813
    mixins: [
22814
        'Ext.util.StoreHolder'
22815
    ],
22816
    config: {
22817
        titleField: 'title'
22818
    },
22819
    name: 'gridMenuMD',
22820
    id: 'mainTab',
22821
    moduleType: undefined,
22822
    tablenameheader: undefined,
22823
    langId: undefined,
22824
    param: undefined,
22825
    frame: true,
22826
    //style: {
22827
    //    background: '#ffc'
22828
    //},
22829
    //cls: 'modern-tabpanel',
22830
    //bodyStyle: {
22831
    //    background: '#ffc',
22832
    //    padding: '10px'
22833
    //},
22834
    defaults: {
22835
        scrollable: true,
22836
        iconAlign: 'top',
22837
        userSelectable: {
22838
            bodyElement: true
22839
        }
22840
    },
22841
    tabBar: {
22842
        layout: { pack: 'center' }
22843
    },
22844
    initComponent: function () {
22845
        var me = this;
22846
        var hasil = null;
22847
        var _items = [];
22848

    
22849
        // Ambil Daftar Master Data dari PCMEPMDLIST untuk ditampilkan di Tab
22850
        Ext.Ajax.request({
22851
            async: false,
22852
            method: 'POST',
22853
            url: '/UserControl/GetStore',
22854
            params: {
22855
                tableName: 'PCMEPMDLIST',
22856
                param: 'ModuleType[=]' + me.moduleType + ',Language[=]' + me.langId
22857
            },
22858
            success: function (response) {
22859
                var results = Ext.decode(response.responseText);
22860
                hasil = results.data;
22861
            }
22862
        });
22863
        hasil = hasil.sort(MinovaUtil.SortBySeq("Sequence"));
22864

    
22865
        // Jika Daftar Master ada, Load dari Table PA satu persatu ke setiap Tab
22866
        if (hasil.length > 0) {
22867
            Ext.each(hasil, function (rec) {
22868
                if (rec.LayoutType == "L003") { // L003=GRID, DISPLAY, FORM
22869
                    //panelTab+TableName
22870
                    _items.push({
22871
                        xtype: 'panel',
22872
                        iconCls: rec.IconCls, //"fa fa-address-book-o",
22873
                        title: rec.LabelName,
22874
                        name: 'panelTab' + rec.TableName,
22875
                        record: rec, //dipanggil di mainNew1Controller.js
22876
                        tbl: rec.TableName,
22877
                        //layout: 'center', //bikin layout kacau
22878
                        //cls: 'card',
22879
                        //items: [
22880
                        //    //GRID+TableName (minovagrid1)
22881
                        //    {
22882
                        //        xtype: 'minovagrid1new',
22883
                        //        height: 450,
22884
                        //        tableName: rec.TableName,
22885
                        //        storename: 'store' + rec.TableName,
22886
                        //        pagesize: 25,
22887
                        //        name: 'GRID' + rec.TableName,
22888
                        //        margin: '0 0 10 0',
22889
                        //        autoLoad: false,
22890
                        //        param: 'EmployeeID[=]' + getParam("EmployeeID"),
22891
                        //        //Top Toolbar
22892
                        //        tbar: [
22893
                        //            //tbfill
22894
                        //            {
22895
                        //                xtype: 'tbfill'
22896
                        //            },
22897
                        //            //Combo Action
22898
                        //            {
22899
                        //                xtype: 'button',
22900
                        //                text: 'Action',
22901
                        //                name: 'actionGrid' + rec.TableName,
22902
                        //                menu: [
22903
                        //                    //Add
22904
                        //                    {
22905
                        //                        text: 'Add',
22906
                        //                        name: 'add' + rec.TableName,
22907
                        //                        tbl: rec.TableName,
22908
                        //                        style: 'font-family: FontAwesome',
22909
                        //                        iconCls: 'fa-plus-circle',
22910
                        //                        handler: function () {
22911
                        //                            var frmDisplay = Ext.ComponentQuery.query('[name=DISPLAY' + rec.TableName + ']')[0];
22912
                        //                            var frmForm = Ext.ComponentQuery.query('[name=FORM' + rec.TableName + ']')[0];
22913
                        //                            var grdPanel = Ext.ComponentQuery.query('[name=GRID' + rec.TableName + ']')[0];
22914
                        //                            var keyField = getParam("KeyID");
22915
                        //                            var keyValue = getParam("KeyValue");
22916
                        //                            frmDisplay.reset();
22917
                        //                            frmForm.reset();
22918
                        //                            var idseq = 0;
22919
                        //                            var params = {
22920
                        //                                apiController: 'api/Devt',
22921
                        //                                methodName: 'GetLastSeqID',
22922
                        //                                parameter: 'tableName=' + rec.TableName + '&keyField=' + keyField + '&keyValue=' + keyValue
22923
                        //                            };
22924
                        //                            MinovaAjaxPost('/ApiService/Api/', params, function (xhr) {
22925
                        //                                var result = Ext.decode(xhr.responseText);
22926
                        //                                var r = Ext.decode(result.data);
22927
                        //                                idseq = r.data + 1;
22928
                        //                                frmForm.getForm().findField(keyField).setValue(keyValue);
22929
                        //                                frmForm.getForm().findField("SeqID").setValue(idseq);
22930
                        //                            });
22931
                        //                            frmDisplay.setHidden(true);
22932
                        //                            frmForm.setHidden(false);
22933
                        //                            grdPanel.setHidden(true);
22934
                        //                            action = "0";
22935
                        //                        }
22936
                        //                    },
22937
                        //                    //Copy
22938
                        //                    {
22939
                        //                        text: 'Copy',
22940
                        //                        name: 'copy' + rec.TableName,
22941
                        //                        tbl: rec.TableName,
22942
                        //                        iconCls: 'fa-copy',
22943
                        //                        style: 'font-family: FontAwesome',
22944
                        //                        handler: function () {
22945
                        //                            var frmDisplay = Ext.ComponentQuery.query('[name=DISPLAY' + rec.TableName + ']')[0];
22946
                        //                            var frmForm = Ext.ComponentQuery.query('[name=FORM' + rec.TableName + ']')[0];
22947
                        //                            var grdPanel = Ext.ComponentQuery.query('[name=GRID' + rec.TableName + ']')[0];
22948
                        //                            var dtrec = grdPanel.getView().getSelectionModel().getSelection()[0];
22949
                        //                            var keyField = getParam("KeyID");
22950
                        //                            if (dtrec) {
22951
                        //                                frmDisplay.reset();
22952
                        //                                frmForm.reset();
22953
                        //                                frmForm.getForm().setValues(dtrec.data);
22954
                        //                                frmDisplay.setHidden(true);
22955
                        //                                frmForm.setHidden(false);
22956
                        //                                grdPanel.setHidden(true);
22957
                        //                                action = "0";
22958
                        //                                frmForm.getForm().findField(keyField).setValue("");
22959
                        //                            }
22960
                        //                        }
22961
                        //                    },
22962
                        //                    //Edit
22963
                        //                    {
22964
                        //                        text: 'Edit',
22965
                        //                        name: 'edit' + rec.TableName,
22966
                        //                        tbl: rec.TableName,
22967
                        //                        iconCls: 'fa-edit',
22968
                        //                        style: 'font-family: FontAwesome',
22969
                        //                        handler: function () {
22970
                        //                            var frmDisplay = Ext.ComponentQuery.query('[name=DISPLAY' + rec.TableName + ']')[0];
22971
                        //                            var frmForm = Ext.ComponentQuery.query('[name=FORM' + rec.TableName + ']')[0];
22972
                        //                            var grdPanel = Ext.ComponentQuery.query('[name=GRID' + rec.TableName + ']')[0];
22973
                        //                            var dtrec = grdPanel.getView().getSelectionModel().getSelection()[0];
22974
                        //                            if (dtrec) {
22975
                        //                                frmDisplay.reset();
22976
                        //                                frmForm.reset();
22977
                        //                                frmForm.getForm().setValues(dtrec.data);
22978
                        //                                frmDisplay.setHidden(true);
22979
                        //                                frmForm.setHidden(false);
22980
                        //                                grdPanel.setHidden(true);
22981
                        //                                action = "1";
22982
                        //                            }
22983
                        //                        }
22984
                        //                    }
22985
                        //                ]
22986
                        //            },
22987
                        //            //Btn Clear Filter
22988
                        //            {
22989
                        //                text: 'Clear Filters',
22990
                        //                tooltip: 'Clear all filters',
22991
                        //                name: 'clearbtn',
22992
                        //                handler: function () { }
22993
                        //            }
22994
                        //        ],
22995
                        //        //Paging Toolbar
22996
                        //        dockedItems: [
22997
                        //            {
22998
                        //                xtype: 'pagingtoolbar',
22999
                        //                store: 'store' + rec.TableName,
23000
                        //                dock: 'bottom',
23001
                        //                pageSize: me.pagesize,
23002
                        //                displayInfo: true
23003
                        //            }
23004
                        //        ],
23005
                        //        //Event Event itemdblclick
23006
                        //        listeners: {
23007
                        //            'itemdblclick': function (me, record, item, index, e, eOpts) {
23008
                        //                var frmDisplay = Ext.ComponentQuery.query('[name=DISPLAY' + rec.TableName + ']')[0];
23009
                        //                var frmForm = Ext.ComponentQuery.query('[name=FORM' + rec.TableName + ']')[0];
23010
                        //                var grdPanel = Ext.ComponentQuery.query('[name=GRID' + rec.TableName + ']')[0];
23011
                        //                frmDisplay.reset();
23012
                        //                frmForm.reset();
23013
                        //                frmDisplay.getForm().setValues(record.data);
23014
                        //                frmForm.getForm().setValues(record.data);
23015
                        //                frmDisplay.setHidden(false);
23016
                        //                frmForm.setHidden(true);
23017
                        //                grdPanel.setHidden(true);
23018
                        //                action = "1";
23019
                        //            }
23020
                        //        }
23021
                        //    },
23022
                        //    //DISPLAY+TableName (minovaform)
23023
                        //    {
23024
                        //        xtype: 'minovaformnew',
23025
                        //        name: 'DISPLAY' + rec.TableName,
23026
                        //        id: 'DISPLAY' + rec.TableName,
23027
                        //        itemId: 'DISPLAY' + rec.TableName,
23028
                        //        tableName: rec.TableName,
23029
                        //        isDisplay: true,
23030
                        //        hidden: true,
23031
                        //        buttons: [
23032
                        //            {
23033
                        //                text: 'Edit',
23034
                        //                name: 'editDISPLAY' + rec.TableName,
23035
                        //                iconCls: 'fa-edit',
23036
                        //                style: 'font-family: FontAwesome',
23037
                        //                handler: function () {
23038
                        //                    var frmDisplay = Ext.ComponentQuery.query('[name=DISPLAY' + rec.TableName + ']')[0];
23039
                        //                    var frmForm = Ext.ComponentQuery.query('[name=FORM' + rec.TableName + ']')[0];
23040
                        //                    var grdPanel = Ext.ComponentQuery.query('[name=GRID' + rec.TableName + ']')[0];
23041
                        //                    frmDisplay.setHidden(true);
23042
                        //                    frmForm.setHidden(false);
23043
                        //                    grdPanel.setHidden(true);
23044
                        //                }
23045
                        //            },
23046
                        //            {
23047
                        //                text: 'Cancel',
23048
                        //                name: 'cancelDISPLAY' + rec.TableName,
23049
                        //                iconCls: 'fa-reply',
23050
                        //                style: 'font-family: FontAwesome',
23051
                        //                handler: function () {
23052
                        //                    var frmDisplay = Ext.ComponentQuery.query('[name=DISPLAY' + rec.TableName + ']')[0];
23053
                        //                    var frmForm = Ext.ComponentQuery.query('[name=FORM' + rec.TableName + ']')[0];
23054
                        //                    var grdPanel = Ext.ComponentQuery.query('[name=GRID' + rec.TableName + ']')[0];
23055
                        //                    frmDisplay.setHidden(true);
23056
                        //                    frmForm.setHidden(true);
23057
                        //                    grdPanel.setHidden(false);
23058
                        //                }
23059
                        //            }
23060
                        //        ]
23061
                        //    },
23062
                        //    //FORM+TableName (minovaform)
23063
                        //    {
23064
                        //        xtype: 'minovaformnew',
23065
                        //        name: 'FORM' + rec.TableName,
23066
                        //        id: 'FORM' + rec.TableName,
23067
                        //        itemId: 'FORM' + rec.TableName,
23068
                        //        tableName: rec.TableName,
23069
                        //        isDisplay: false,
23070
                        //        hidden: true,
23071
                        //        buttons: [
23072
                        //            {
23073
                        //                text: 'Save',
23074
                        //                name: 'saveFORM' + rec.TableName,
23075
                        //                iconCls: 'fa-save',
23076
                        //                style: 'font-family: FontAwesome',
23077
                        //                handler: function () {
23078
                        //                    var frmDisplay = Ext.ComponentQuery.query('[name=DISPLAY' + rec.TableName + ']')[0];
23079
                        //                    var frmForm = Ext.ComponentQuery.query('[name=FORM' + rec.TableName + ']')[0];
23080
                        //                    var grdPanel = Ext.ComponentQuery.query('[name=GRID' + rec.TableName + ']')[0];
23081
                        //                    var frm = frmForm.getForm();
23082
                        //                    if (frm.isValid()) {
23083
                        //                        var keyField = getParam("KeyID");
23084
                        //                        var table = rec.TableName;
23085
                        //                        var data = Ext.encode(frmForm.getValues());
23086
                        //                        var token = MinovaUtil.SESSIONS.Token;
23087
                        //                        var params = {
23088
                        //                            apiController: 'api/Devt',
23089
                        //                            methodName: 'SaveTableMaster',
23090
                        //                            parameter: 'tableName=' + table + '&data=' + data + '&action=' + action + '&token=' + token
23091
                        //                        };
23092
                        //                        MinovaAjaxPost('/ApiService/Api/', params, function (xhr) {
23093
                        //                            var result = Ext.decode(xhr.responseText);
23094
                        //                            var r = Ext.decode(result.data);
23095
                        //                            if (r.success) {
23096
                        //                                frmDisplay.setHidden(true);
23097
                        //                                frmForm.setHidden(true);
23098
                        //                                grdPanel.setHidden(false);
23099
                        //                                grdPanel.getStore().reload();
23100
                        //                                MinovaMessage('Not Null', '000006', '', 'S');
23101
                        //                            } else {
23102
                        //                                MinovaMessage(' Not Null ', ' 000005 ', r.message.text, 'E');
23103
                        //                            }
23104
                        //                        });
23105
                        //                    }
23106
                        //                }
23107
                        //            },
23108
                        //            {
23109
                        //                text: 'Delete',
23110
                        //                name: 'deleteFORM' + rec.TableName,
23111
                        //                iconCls: 'fa-trash-o',
23112
                        //                style: 'font-family: FontAwesome ',
23113
                        //                handler: function () {
23114
                        //                    MinovaMessage(' Message ', ' 000007 ', ' ', 'C', function (respone) {
23115
                        //                        if (respone == "yes") {
23116
                        //                            var frmDisplay = Ext.ComponentQuery.query('[name=DISPLAY' + rec.TableName + ']')[0];
23117
                        //                            var frmForm = Ext.ComponentQuery.query('[name=FORM' + rec.TableName + ']')[0];
23118
                        //                            var grdPanel = Ext.ComponentQuery.query('[name=GRID' + rec.TableName + ']')[0];
23119
                        //                            var frm = frmForm.getForm();
23120
                        //                            if (frm.isValid()) {
23121
                        //                                var keyField = getParam("KeyID");
23122
                        //                                var table = rec.TableName;
23123
                        //                                var data = Ext.encode(frmForm.getValues());
23124
                        //                                var token = MinovaUtil.SESSIONS.Token;
23125
                        //                                action = "2";
23126
                        //                                var params = {
23127
                        //                                    apiController: 'api/Devt',
23128
                        //                                    methodName: 'SaveTableMaster',
23129
                        //                                    parameter: 'tableName=' + table + '&data=' + data + '&action=' + action + '&token=' + token
23130
                        //                                };
23131
                        //                                MinovaAjaxPost('/ApiService/Api/', params, function (xhr) {
23132
                        //                                    var result = Ext.decode(xhr.responseText);
23133
                        //                                    var r = Ext.decode(result.data);
23134
                        //                                    if (r.success) {
23135
                        //                                        frmDisplay.setHidden(true);
23136
                        //                                        frmForm.setHidden(true);
23137
                        //                                        grdPanel.setHidden(false);
23138
                        //                                        grdPanel.getStore().reload();
23139
                        //                                        MinovaMessage('Not Null', '000006', '', 'S');
23140
                        //                                    } else {
23141
                        //                                        MinovaMessage(' Not Null ', ' 000005 ', r.message.text, 'E');
23142
                        //                                    }
23143
                        //                                });
23144
                        //                            }
23145
                        //                        }
23146
                        //                    });
23147
                        //                }
23148
                        //            },
23149
                        //            {
23150
                        //                text: 'Cancel',
23151
                        //                name: 'cancelFORM' + rec.TableName,
23152
                        //                iconCls: 'fa-reply',
23153
                        //                style: 'font-family: FontAwesome',
23154
                        //                handler: function () {
23155
                        //                    MinovaMessage('Message', '000011', '', 'C', function (respone) {
23156
                        //                        if (respone == "yes") {
23157
                        //                            var frmDisplay = Ext.ComponentQuery.query('[name=DISPLAY' + rec.TableName + ']')[0];
23158
                        //                            var frmForm = Ext.ComponentQuery.query('[name=FORM' + rec.TableName + ']')[0];
23159
                        //                            var grdPanel = Ext.ComponentQuery.query('[name=GRID' + rec.TableName + ']')[0];
23160
                        //                            frmDisplay.setHidden(true);
23161
                        //                            frmForm.setHidden(true);
23162
                        //                            grdPanel.setHidden(false);
23163
                        //                            grdPanel.getStore().reload();
23164
                        //                        }
23165
                        //                    });
23166
                        //                }
23167
                        //            }
23168
                        //        ]
23169
                        //    }
23170
                        //]
23171
                        layoutType: rec.LayoutType //dikomen kalau mau test hilangkan items, bikin layout kacau                       
23172
                    })
23173
                }
23174
            })
23175
        }
23176
        Ext.applyIf(me, {
23177
            items: _items,
23178
            store: hasil
23179
        });
23180
        me.callParent(arguments);
23181
        this.bindStore(this.store, true);
23182
    },
23183

    
23184
    getStoreListeners: function () {
23185
        var me = this;
23186

    
23187
        return {
23188
            refresh: me.onDataRefresh,
23189
            /*replace: me.onReplace,
23190
            add: me.onAdd,
23191
            remove: me.onRemove,
23192
            update: me.onUpdate,
23193
            clear: me.onDataRefresh,
23194
            beginupdate: me.onBeginUpdate,
23195
            endupdate: me.onEndUpdate*/
23196
        };
23197
    },
23198

    
23199
    onBindStore: function (store) {
23200
        //this.onDataRefresh(store);
23201
    },
23202

    
23203
    onDataRefresh: function (store) {
23204
        var me = this,
23205
            titleField = me.getTitleField();
23206

    
23207
        store.each(function (record) {
23208
            var tab = me.getTabByRecord(record);
23209

    
23210
            if (!tab) {
23211
                me.add({
23212
                    title: record.get(titleField)
23213
                });
23214
            }
23215
        });
23216

    
23217
        if (!me.getActiveTab()) {
23218
            me.setActiveTab(0);
23219
        }
23220
    },
23221

    
23222
    getTabByRecord: function (record) {
23223
        var items = this.items,
23224
            tab;
23225

    
23226
        items.each(function (item) {
23227
            if (item.$record === record) {
23228
                tab = item;
23229

    
23230
                return false;
23231
            }
23232
        });
23233

    
23234
        return tab;
23235
    }
23236
});
23237

    
23238
Ext.define('MinovaUtil.MinovaES.MinovaTabListORMNew', {
23239
    extend: 'Ext.tab.Panel',
23240
    alias: ['widget.MinovaTabListORMNew'],
23241
    mixins: [
23242
        'Ext.util.StoreHolder'
23243
    ],
23244
    config: {
23245
        titleField: 'title'
23246
    },
23247
    id: 'mainTab',
23248
    //moduleType: undefined,
23249
    //tablenameheader: undefined,
23250
    //langId: undefined,
23251
    //param: undefined,
23252
    //frame: true,
23253
    //style: {
23254
    //    background: '#ffc'
23255
    //},
23256
    //cls: 'modern-tabpanel',
23257
    //bodyStyle: {
23258
    //    background: '#ffc',
23259
    //    padding: '10px'
23260
    //},
23261
    defaults: {
23262
        scrollable: true,
23263
        iconAlign: 'top',
23264
        userSelectable: {
23265
            bodyElement: true
23266
        }
23267
    },
23268
    tabBar: {
23269
        layout: { pack: 'center' }
23270
    },
23271
    initComponent: function () {
23272
        var me = this;
23273
        var hasil = null;
23274
        var _items = [];
23275
        Ext.applyIf(me, {
23276
            items: _items,
23277
            //store: hasil
23278
            store: Ext.create('Ext.data.Store', {
23279
                storeId: 'gridMenuMDOrm',
23280
                autoLoad: false,
23281
                proxy: {
23282
                    method: 'POST',
23283
                    type: 'ajax',
23284
                    //url: '../../extended/data/menu_md_orm.js',
23285
                    reader: {
23286
                        type: 'json',
23287
                        root: 'data'
23288
                    }
23289
                }
23290
            }),
23291
        });
23292
        me.callParent(arguments);
23293
        this.bindStore(this.store, true);
23294
    },
23295

    
23296
    //listeners: {
23297
    //    'viewready': function (grid) {
23298
    //        grid.getSelectionModel().select(0);
23299
    //        grid.fireEvent('rowClick', grid, 0);
23300
    //    }
23301
    //},
23302
    getStoreListeners: function () {
23303
        var me = this;
23304

    
23305
        return {
23306
            refresh: me.onDataRefresh,
23307
            /*replace: me.onReplace,
23308
            add: me.onAdd,
23309
            remove: me.onRemove,
23310
            update: me.onUpdate,
23311
            clear: me.onDataRefresh,
23312
            beginupdate: me.onBeginUpdate,
23313
            endupdate: me.onEndUpdate*/
23314
        };
23315
    },
23316

    
23317
    onBindStore: function (store) {
23318
        this.onDataRefresh(store);
23319
    },
23320

    
23321
    onDataRefresh: function (store) {
23322
        var me = this,
23323
            titleField = me.getTitleField();
23324
        me.removeAll();
23325
        store.each(function (record) {
23326
            var tab = me.getTabByRecord(record);
23327

    
23328
            if (!tab) {
23329
                me.add({
23330
                    iconCls: 'fa fa-address-book-o', //record.get('IconCls')
23331
                    title: record.get('LabelName'),
23332
                    name: 'panelTab' + record.get('TableName'),
23333
                    record: record, //dipanggil di mainNew1Controller.js
23334
                    tbl: record.get('TableName'),
23335
                    layoutType: record.get('LayoutType')
23336
                });
23337
            }
23338
        });
23339

    
23340
        if (!me.getActiveTab()) {
23341
            me.setActiveTab(0);
23342
        }
23343
    },
23344

    
23345
    getTabByRecord: function (record) {
23346
        var items = this.items,
23347
            tab;
23348

    
23349
        items.each(function (item) {
23350
            //if (item.$record === record) {
23351
            if (item.record === record) {
23352
                tab = item;
23353

    
23354
                return false;
23355
            }
23356
        });
23357

    
23358
        return tab;
23359
    }
23360
});
23361
/* BEGIN YN 20211216 */
23362
//panelTab->panelTab+TableName->GRID+TableName | DISPLAY+TableName | FORM+TableName 
23363
Ext.define('MinovaUtil.MinovaES.MinovaFlowArrow', {
23364
    extend: 'Ext.panel.Panel',
23365
    alias: ['widget.MinovaFlowArrow'],
23366
    config: {
23367
        titleField: 'title'
23368
    },
23369
    name: 'flowArrow',
23370
    id: 'flowArrow',
23371
    empId: undefined,
23372
    now: undefined,
23373
    regId: undefined,
23374
    bizId: undefined,
23375
    param: undefined,
23376
    //frame: true,
23377
    //style: {
23378
    //    background: '#ffc'
23379
    //},
23380
    //cls: 'modern-tabpanel',
23381
    //bodyStyle: {
23382
    //    background: '#ffc',
23383
    //    padding: '10px'
23384
    //},
23385
    defaults: {
23386
        scrollable: true,
23387
        iconAlign: 'top',
23388
        userSelectable: {
23389
            bodyElement: true
23390
        }
23391
    },
23392
    initComponent: function () {
23393
        var me = this;
23394
        var hasil = null;
23395
        var _items = [];
23396
        // Ambil Flow Task untuk ditampilkan di Tab
23397
        //Ext.Ajax.request({
23398
        //    async: false,
23399
        //    method: 'POST',
23400
        //    url: '/UserControl/GetStore',
23401
        //    params: {
23402
        //        empId: me.empId,
23403
        //        regId: me.regId,
23404
        //        bizId: me.bizId,
23405
        //        param: me.param
23406
        //    },
23407
        //    success: function (response) {
23408
        //        var results = Ext.decode(response.responseText);
23409
        //        hasil = results.data;
23410
        //    }
23411
        //});
23412
        //if (hasil == null) {
23413
        //    htmltxt = '<div class="arrow-steps clearfix"></div>';
23414
        //}
23415
        //else {
23416
        //    if (hasil.length > 0) {
23417
        //        htmltxt = '<div class="arrow-steps clearfix">';
23418
        //        Ext.each(hasil, function (rec) {
23419
        //            if (rec.isnow == '1') {
23420
        //                htmltxt += '<div class="step current"><span>' + rec.taskname + '</span><br>';
23421
        //                htmltxt += '<span>' + rec.userid + '</span><br>';
23422
        //                htmltxt += '<span>' + rec.wfstatus + '</span></div>';
23423
        //            }
23424
        //            else {
23425
        //                htmltxt += '<div class="step"><span>' + rec.taskname + '</span><br>';
23426
        //                htmltxt += '<span>' + rec.userid + '</span><br>';
23427
        //                htmltxt += '<span>' + rec.wfstatus + '</span></div>';
23428
        //            }
23429
        //        })
23430
        //        htmltxt += '</div>';
23431
        //    }
23432
        //}
23433
        //_items.push({
23434
        //    xtype: 'panel',
23435
        //    html: htmltxt,
23436
        //    name: 'flowList',
23437
        //})
23438

    
23439
        //    html: '<div class="arrow-steps clearfix"><div class="step current"><span>Step 1</span></div><div class="step"><span>Step 2</span></div><div class="step"><span>Step 3</span></div><div class="step"><span>Step 4</span></div></div></div>',
23440

    
23441
        Ext.applyIf(me, {
23442
            items: _items
23443
        });
23444
        me.callParent(arguments);
23445
    }
23446
});
23447

    
23448
/*NonEditableGrid ESS Generator YN 20211216 */
23449
Ext.define('MinovaUtil.MinovaES.MinovaWorkflowNonEditableGrid', {
23450
    extend: 'Ext.form.Panel',
23451
    alias: ['widget.minovaworkflownoneditablegrid'],
23452
    requires: [
23453
        'Ext.grid.plugin.CellEditing',
23454
        'Ext.grid.RowNumberer',
23455
        'Ext.grid.Panel',
23456
    ],
23457
    cls: 'grid-ess',
23458
    anchor: '100%',
23459
    tableName: undefined,
23460
    tableNameT: undefined,
23461
    tableNameKey: undefined,
23462
    tableNameTKey: undefined,
23463
    hideButton: undefined,
23464
    multiSelect: undefined,
23465
    formname: this.name,
23466
    bizprocid: undefined,
23467
    bizflowid: undefined,
23468
    taskid: undefined,
23469
    features: undefined,
23470
    //height: 400,
23471
    minHeight: 20,
23472
    maxHeight: 500,
23473
    headerLayout: undefined,
23474
    summaryType: undefined,
23475
    labelText: undefined,
23476
    find: function (searchData, target, accum = []) {
23477
        target.forEach((f) => {
23478
            if (f.columns) {
23479
                //find(searchData, f.columns, accum)
23480
                //console.log(f.columns);
23481
                const newf = f.columns.map(o => {
23482
                    if (o.dataIndex == searchData.dataIndex) {
23483
                        searchData.menuDisabled = true;
23484
                        return searchData;
23485
                    } else {
23486
                        o.menuDisabled = true;
23487
                        return o
23488
                    }
23489
                });                
23490
                accum.push({
23491
                    header: f.header,
23492
                    //columns: {
23493
                    //    defaults: {
23494
                    //        menuDisabled: true
23495
                    //    },
23496
                    //    items: newf
23497
                    //}
23498
                    columns: newf
23499
                });
23500
            } else {
23501
                if (f.dataIndex.includes(searchData.dataIndex)) {
23502
                    accum.push(searchData);
23503
                }
23504
                else {
23505
                    accum.push(f);
23506
                }
23507
            }
23508
        })
23509
        return accum;
23510

    
23511
    },
23512
    initComponent: function () {
23513
        var me = this;
23514
        var isLookup = me.isLookup;
23515
        var hide_ = false;
23516
        var widthLock = 250;
23517
        var checkSelection = '';
23518
        if (me.hideButton == true) {
23519
            hide_ = true;
23520
        }
23521
        if (me.multiSelect) {
23522
            locking = false;
23523
            checkSelection = 'checkboxmodel';
23524
            widthLock = 40;
23525
        }
23526
        var tableName = me.tableName;
23527
        var features = me.features;
23528
        var cols = [];
23529
        var fieldStore = [];
23530
        var _url = 'GetAllField';
23531
        var hasil = null;
23532
        var height = me.height;
23533
        var storeID = 'store' + me.tableName;
23534
        var gridName = 'grid' + me.name;
23535
        if (me.storeName) {
23536
            storeID = me.storeName;
23537
        }
23538
        var LangID = MinovaUtil.GetLangID();
23539
        var parameter = "LangID='" + LangID + "',BizProcessID='" + me.bizprocid + "',TaskID='" + me.taskid + "',TableName='" + me.tableName + "'";
23540
        Ext.Ajax.request({
23541
            async: false,
23542
            method: 'POST',
23543
            url: '/UserControl/GetStore',
23544
            params: {
23545
                tableName: 'PDSWFSTRUCTUREFIELD',
23546
                param: parameter
23547
            },
23548
            success: function (response) {
23549
                var results = Ext.decode(response.responseText);
23550
                hasil = results.data;
23551
            }
23552
        });
23553
        //cols.push({
23554
        //    xtype: 'rownumberer'
23555
        //});
23556
        var addData = 'var data={';
23557
        if (hasil.length > 0) {
23558
            Ext.each(hasil, function (rec) {
23559
                fieldStore.push(rec.FieldName);
23560
                if (rec.FieldName != 'Sequence') {
23561
                    addData = addData + rec.FieldName + ":" + "'',";
23562
                }
23563
                var null_ = null;
23564
                var ReadOnly_ = false;
23565
                if (rec.IsRequired == '1') {
23566
                    null_ = false;
23567
                } else {
23568
                    null_ = true;
23569
                }
23570
                var Hidden_ = false;
23571
                if (rec.IsReadOnly == '1') {
23572
                    ReadOnly_ = true;
23573
                }
23574
                if (rec.IsVisible == '1') {
23575
                    switch (rec.FormatRef) {
23576
                        case "date":
23577
                            cols.push({
23578
                                xtype: 'minovadatecolumn',
23579
                                hidden: Hidden_,
23580
                                text: rec.HeaderTitle,
23581
                                dataIndex: rec.FieldName,
23582
                                filter: {
23583
                                    itemDefaults: {
23584
                                        emptyText: 'Search for...',
23585
                                    }
23586
                                }
23587
                            });
23588
                            break
23589
                        case "amount":
23590
                            cols.push({
23591
                                xtype: 'minovacurrancycolumn',
23592
                                align: 'right',
23593
                                text: rec.HeaderTitle,
23594
                                dataIndex: rec.FieldName,
23595
                                hidden: Hidden_,
23596
                                filter: {
23597
                                    itemDefaults: {
23598
                                        emptyText: 'Search for...'
23599
                                    }
23600
                                }
23601
                            });
23602
                            break
23603
                        default:
23604
                            if (rec.DataRef == 'CREATEBY' || rec.DataRef == 'CHANGEBY' || rec.DataRef == 'CREATEDT' || rec.DataRef == 'CHANGEDT') {
23605
                                cols.push({
23606
                                    text: rec.HeaderTitle,
23607
                                    dataIndex: rec.FieldName,
23608
                                    width: 100,
23609
                                    filter: {
23610
                                        type: 'string',
23611
                                        itemDefaults: {
23612
                                            emptyText: 'Search for...'
23613
                                        }
23614
                                    }
23615
                                });
23616
                            } else if (rec.SearchType == '0') {
23617
                                var valueField = null;
23618
                                var displayValue = null;
23619
                                var TableRef = undefined;
23620
                                if (rec.TableRef != '') {
23621
                                    TableRef = rec.TableRef;
23622
                                    Ext.Ajax.request({
23623
                                        async: false,
23624
                                        method: 'POST',
23625
                                        url: '/UserControl/GetStore',
23626
                                        params: {
23627
                                            tableName: 'SDATATABLEFIELD',
23628
                                            param: 'TableName[equal]' + rec.TableRef
23629
                                        },
23630
                                        success: function (response) {
23631
                                            var results = Ext.decode(response.responseText);
23632
                                            data_ = results.data;
23633
                                            if (data_ != undefined) {
23634
                                                valueField_ = $.grep(data_, function (r) {
23635
                                                    return r.ValueField == '1'
23636
                                                });
23637
                                                valueField = valueField_[0].FieldName
23638
                                                displayValue_ = $.grep(data_, function (r) {
23639
                                                    return r.DisplayValue == '1'
23640
                                                });
23641
                                                displayValue = displayValue_[0].FieldName
23642
                                            }
23643
                                        }
23644
                                    });
23645
                                }
23646
                                Ext.create('Ext.data.Store', {
23647
                                    storeId: 'store_' + me.tableName + rec.FieldName,
23648
                                    autoLoad: true,
23649
                                    gridRefresh: 'grid' + me.tableName,
23650
                                    proxy: {
23651
                                        method: 'POST',
23652
                                        type: 'ajax',
23653
                                        url: '/UserControl/GetStoreAuth',
23654
                                        extraParams: {
23655
                                            tableName: TableRef,
23656
                                            param: rec.ParamCombo,
23657
                                            menuId: MinovaUtil.GetMenuID()
23658
                                        },
23659
                                        reader: {
23660
                                            type: 'json',
23661
                                            root: 'data',
23662
                                            totalProperty: 'data[0].TotalCount',
23663
                                            grid: "grid" + me.tableName,
23664
											//grid: me,
23665
                                            // THIS IS THE FUNCTION YOU NEED TO MANIPULATE THE DATA
23666
                                            // getData: function (data) {
23667
												// Ext.ComponentQuery.query("[name=" + this.grid + "]")[0].view.refresh();												
23668
                                                // return data;
23669
                                            // }
23670
                                        }
23671
                                    }
23672
                                });
23673
                                cols.push({
23674
                                    //xtype : 'minovacombocolumn',
23675
                                    hidden: Hidden_,
23676
                                    text: rec.HeaderTitle,
23677
                                    dataIndex: rec.FieldName,
23678
                                    width: (rec.Length * 6.5 + 20) > 300 ? 300 : rec.Length * 6.5 + 30,
23679
                                    summaryType: function (records) {
23680
                                        var suma = 0;
23681
                                        if (me.summaryType == 'average') {
23682
                                            // Sumar en la columna solo las lineas que estan marcadas para ser sumadas a los totales
23683
                                            Ext.each(records, function (record, index) {
23684
                                                if (record.get(rec.FieldName)) {
23685
                                                    suma = suma + parseFloat(record.get(rec.FieldName).replace(",", "."));
23686
                                                }
23687
                                            });
23688
                                            (records.length == 0) ? suma = 0 : suma = suma / records.length;
23689
                                        }
23690
                                        else if (me.summaryType == 'sum') {
23691
                                            // Sumar en la columna solo las lineas que estan marcadas para ser sumadas a los totales
23692
                                            Ext.each(records, function (record, index) {
23693
                                                if (record.get(rec.FieldName)) {
23694
                                                    suma = suma + parseFloat(record.get(rec.FieldName).replace(",", "."));
23695
                                                }
23696
                                            });
23697
                                        }
23698
                                        
23699
                                        return suma;
23700
                                    },
23701
                                    //valueField : valueField,
23702
                                    //displayField : displayValue,
23703
                                    //store : 'store_' + me.tableName + rec.FieldName,
23704
                                    //renderer: function (value) {
23705
                                    //    var store = Ext.data.StoreManager.lookup('store_' + me.tableName + rec.FieldName);
23706
                                    //    var index = store.find(valueField, value);
23707
                                    //    var val = "";
23708
                                    //    if (index != -1) {
23709
                                    //        var rc = store.getAt(index);
23710
                                    //        val = rc.get(displayValue);
23711
                                    //    } else {
23712
                                    //        val = value;
23713
                                    //    }
23714
                                    //    return val;
23715
                                    //},
23716
                                    //filter: {
23717
                                    //    type: 'list',
23718
                                    //    itemDefaults: {
23719
                                    //        emptyText: 'Search for...'
23720
                                    //    }
23721
                                    //}
23722
                                });
23723
                            } else if (rec.SearchType == '5') {
23724
                                var valueField = null;
23725
                                var displayValue = null;
23726
                                var AdditionaldisplayValue = null;
23727
                                var TableRef = undefined;
23728
                                if (rec.TableRef != '') {
23729
                                    TableRef = rec.TableRef;
23730
                                    Ext.Ajax.request({
23731
                                        async: false,
23732
                                        method: 'POST',
23733
                                        url: '/UserControl/GetStore',
23734
                                        params: {
23735
                                            tableName: 'SDATATABLEFIELD',
23736
                                            param: 'TableName[equal]' + rec.TableRef
23737
                                        },
23738
                                        success: function (response) {
23739
                                            var results = Ext.decode(response.responseText);
23740
                                            data_ = results.data;
23741
                                            if (data_ != undefined) {
23742
                                                valueField_ = $.grep(data_, function (r) {
23743
                                                    return r.ValueField == '1'
23744
                                                });
23745
                                                if (valueField_.length > 0) {
23746
                                                    valueField = valueField_[0].FieldName
23747
                                                }
23748

    
23749
                                                displayValue_ = $.grep(data_, function (r) {
23750
                                                    return r.DisplayValue == '1' || r.DisplayValue == '2'
23751
                                                });
23752
                                                if (displayValue_.length > 0) {
23753
                                                    displayValue = displayValue_[0].FieldName;
23754
                                                }
23755
                                                if (displayValue_.length >= 2) {
23756
                                                    AdditionaldisplayValue = displayValue_[1].FieldName
23757
                                                }
23758
                                            }
23759
                                        }
23760
                                    });
23761
                                }
23762
                                Ext.create('Ext.data.Store', {
23763
                                    storeId: 'store_' + me.tableName + rec.FieldName,
23764
                                    autoLoad: true,
23765
                                    proxy: {
23766
                                        method: 'POST',
23767
                                        type: 'ajax',
23768
                                        url: '/UserControl/GetStoreAuth',
23769
                                        extraParams: {
23770
                                            tableName: TableRef,
23771
                                            param: rec.ParamCombo,
23772
                                            menuId: MinovaUtil.GetMenuID()
23773
                                        },
23774
                                        reader: {
23775
                                            type: 'json',
23776
                                            root: 'data',
23777
                                            totalProperty: 'data[0].TotalCount'
23778
                                        }
23779
                                    }
23780
                                });
23781
                                cols.push({
23782
                                    //xtype : 'minovacombocolumn',
23783
                                    hidden: Hidden_,
23784
                                    text: rec.HeaderTitle,
23785
                                    dataIndex: rec.FieldName,
23786
                                    //valueField : valueField,
23787
                                    //displayField : displayValue,
23788
                                    //store : 'store_' + me.tableName + rec.FieldName,
23789
                                    tpl: Ext.create('Ext.XTemplate',
23790
                                        '<ul class="x-list-plain"><tpl for=".">',
23791
                                        '<li role="option" class="x-boundlist-item">{' + AdditionaldisplayValue + '} - {' + displayValue + '}</li>',
23792
                                        '</tpl></ul>'),
23793
                                    displayTpl: Ext.create('Ext.XTemplate',
23794
                                        '<tpl for=".">',
23795
                                        '{' + AdditionaldisplayValue + '} - {' + displayValue + '}',
23796
                                        '</tpl>'),
23797
                                    renderer: function (value) {
23798
                                        var store = Ext.data.StoreManager.lookup('store_' + me.tableName + rec.FieldName);
23799
                                        var index = store.find(valueField, value);
23800
                                        var val = "";
23801
                                        if (index != -1) {
23802
                                            var rc = store.getAt(index);
23803
                                            //val = rc.get(displayValue);
23804
                                            val = rc.get(AdditionaldisplayValue) + ' - ' + rc.get(displayValue);
23805
                                        } else {
23806
                                            val = value;
23807
                                        }
23808
                                        return val;
23809
                                    },
23810
                                    filter: {
23811
                                        type: 'list',
23812
                                        itemDefaults: {
23813
                                            emptyText: 'Search for...'
23814
                                        }
23815
                                    }
23816
                                });
23817
                            } else if (rec.SearchType == '2') {
23818
                                var triger = (rec.TriggerCombo).split('$');
23819
                                var targetField_ = triger[0];
23820
                                var fieldValue_ = triger[1];
23821
                                cols.push({
23822
                                    text: rec.HeaderTitle,
23823
                                    hidden: Hidden_,
23824
                                    dataIndex: rec.FieldName,
23825
                                    filter: {
23826
                                        itemDefaults: {
23827
                                            emptyText: 'Search for...'
23828
                                        }
23829
                                    }
23830
                                });
23831
                            } else if (rec.SearchType == '3') {
23832
                                cols.push({
23833
                                    text: rec.HeaderTitle,
23834
                                    hidden: Hidden_,
23835
                                    dataIndex: rec.FieldName,
23836
                                    filter: {
23837
                                        itemDefaults: {
23838
                                            emptyText: 'Search for...'
23839
                                        }
23840
                                    }
23841
                                });
23842
                            } else if (rec.SearchType != '0' && rec.SearchType != '1' && rec.SearchType != '3' && (rec.FieldName == 'EmployeeID' || rec.FieldName == 'ApplicantID' || rec.FieldName == 'EmployeeIDFrom' || rec.FieldName == 'EmployeeIDTo') && isLookup != true) {
23843
                                var triger = (rec.TriggerCombo).split('&');
23844
                                var targetField_ = triger[0];
23845
                                var fieldValue_ = triger[0];
23846
                                cols.push({
23847
                                    text: rec.HeaderTitle,
23848
                                    hidden: Hidden_,
23849
                                    dataIndex: rec.FieldName,
23850
                                    filter: {
23851
                                        itemDefaults: {
23852
                                            emptyText: 'Search for...'
23853
                                        }
23854
                                    }
23855
                                });
23856
                            } else if (rec.SearchType == '4' && isLookup != true) {
23857
                                cols.push({
23858
                                    text: rec.HeaderTitle,
23859
                                    hidden: Hidden_,
23860
                                    dataIndex: rec.FieldName,
23861
                                    filter: {
23862
                                        itemDefaults: {
23863
                                            emptyText: 'Search for...'
23864
                                        }
23865
                                    }
23866
                                });
23867
                            } else if (rec.FixedValue != '') { // add by taufan
23868
                                cols.push({
23869
                                    text: rec.HeaderTitle,
23870
                                    hidden: Hidden_,
23871
                                    dataIndex: rec.FieldName,
23872
                                    filter: {
23873
                                        itemDefaults: {
23874
                                            emptyText: 'Search for...'
23875
                                        }
23876
                                    },
23877
                                    renderer: function (value) {
23878
                                        var val = "";
23879
                                        var storeData = [];
23880
                                        var str = rec.FixedValue;
23881
                                        var hasil = str.split('||');
23882
                                        hasil.forEach(function (h) {
23883
                                            store_ = h.split('=')
23884
                                            storeData.push({
23885
                                                code: store_[0],
23886
                                                desc: store_[1]
23887
                                            });
23888
                                        });
23889
                                        var item = storeData.find(x => x.code == value);
23890
                                        if (item != undefined) {
23891
                                            val = item.desc;
23892
                                        }
23893
                                        return val;
23894
                                    }
23895
                                });
23896
                            } else {
23897
                                _xtype = 'textfield';
23898
                                if (rec.Length > 250) {
23899
                                    _xtype = 'textareafield';
23900
                                }
23901
                                var _custumFunc = null;
23902
                                Ext.Ajax.request({
23903
                                    async: false,
23904
                                    method: 'POST',
23905
                                    url: '/UserControl/GetStore',
23906
                                    params: {
23907
                                        tableName: 'SDATATABLEFIELD',
23908
                                        param: 'FieldName[equal]' + rec.FieldName + ',TableName[equal]' + me.tableName
23909
                                    },
23910
                                    success: function (response) {
23911
                                        var results = Ext.decode(response.responseText);
23912
                                        data_ = results.data[0];
23913
                                        if (data_ != undefined) {
23914
                                            _custumFunc = data_.SelectFunction;
23915
                                        }
23916
                                    }
23917
                                });
23918
                                cols.push({
23919
                                    text: rec.HeaderTitle,
23920
                                    xtype: 'gridcolumn',
23921
                                    hidden: Hidden_,
23922
                                    dataIndex: rec.FieldName,
23923
                                    filter: {
23924
                                        itemDefaults: {
23925
                                            emptyText: 'Search for...'
23926
                                        }
23927
                                    },
23928
                                    cellWrap: true,
23929
                                    //autoSizeColumn: true,
23930
                                    width: (rec.Length * 6.5 + 20) > 300 ? 300 : rec.Length * 6.5 + 30,
23931
                                    flex: (rec.Length == 'EISelfComent') ? 1 : 0,
23932
                                    renderer: function (v) {
23933
                                        result = v.replace(/\r\n\r\n/g, "</p><p>").replace(/\n\n/g, "</p><p>");
23934
                                        result = result.replace(/\r\n/g, "<br />").replace(/\n/g, "<br />");
23935
                                        return result
23936
                                    }
23937
                                });
23938
                            }
23939
                            break
23940
                    }
23941
                } else {
23942
                    cols.push({
23943
                        text: rec.HeaderTitle,
23944
                        hidden: Hidden_,
23945
                        dataIndex: rec.FieldName,
23946
                        hidden: true,
23947
                        filter: {
23948
                            itemDefaults: {
23949
                                emptyText: 'Search for...'
23950
                            }
23951
                        }
23952
                    });
23953
                }
23954
            });
23955

    
23956
        };
23957
        //Sesuaikan Header Layout
23958
        var col = me.headerLayout;
23959
        if (me.headerLayout != undefined) {
23960
            cols.forEach((f) => {
23961
                col = me.find(f, col);
23962
            })
23963
            cols = col;
23964
        }
23965
        addData = addData + "}";
23966
        Ext.applyIf(me, {            
23967
            items: [{
23968
                xtype: 'grid',
23969
                id: gridName,
23970
                name: gridName,
23971
                tableName: me.tableName,
23972
                tableNameT: me.tableNameT,
23973
                tableNameKey: me.tableNameKey,
23974
                tableNameTKey: me.tableNameTKey,
23975
                minHeight: me.minHeight,
23976
                maxHeight: me.maxHeight,
23977
                //height: me.height,                
23978
                //scrollable: true,
23979
                //flex: 1,
23980
                addFlag: true,
23981
                deleteFlag: true,
23982
                store: Ext.create('Ext.data.Store', {
23983
                    storeId: storeID,
23984
                    fields: fieldStore,
23985
                    //groupField: 'QuestionGroup',
23986
                    grouper: {
23987
                        sortProperty: 'SeqQuest',
23988
                        groupFn: function (record) {
23989
                            return record.get('QuestionGroup');
23990
                        }
23991
                    },
23992
                    proxy: {
23993
                        method: 'POST',
23994
                        type: 'ajax',
23995
                        url: '',
23996
                        reader: {
23997
                            type: 'json',
23998
                            root: 'data'
23999
                        }
24000
                    }
24001
                }),
24002
                dockedItems: [{
24003
                    xtype: 'toolbar',
24004
                    dock: 'bottom',
24005
                    items: [
24006
                        {
24007
                            xtype: 'label',
24008
                            html: me.labelText,
24009
                            margin: '0 0 10 0'
24010
                        },
24011
                        {
24012
                            text: 'Add',
24013
                            hidden: hide_,
24014
                            name: tableName + 'Add',
24015
                            iconCls: 'fa-plus-circle',
24016
                            style: 'font-family: FontAwesome',
24017
                            handler: function (btn, e, eOpts) {
24018
                                var grid = Ext.getCmp(gridName);
24019
                                if (grid.addFlag === true) {
24020
                                    var store = Ext.StoreMgr.lookup(storeID)
24021
                                    idx = store.getCount();
24022
                                    var action = getParam('action');
24023
                                    var data = '';
24024
                                    var Sequence = 0;
24025
                                    if (idx == 0) {
24026
                                        Sequence = 1;
24027
                                    } else {
24028
                                        Sequence = 1 + idx;
24029
                                    }
24030
                                    var seq = 'Sequence';
24031
                                    var SequenceValue = Sequence;
24032
                                    eval(addData);
24033
                                    data[seq] = SequenceValue;
24034
                                    store.insert(idx, data);
24035
                                    var grdPanel = Ext.ComponentQuery.query('[name=grid' + me.name + ']')[0];
24036
                                    //var dtrec = grdPanel.getView().getSelectionModel().getSelection()[0];
24037
                                    grdPanel.getView().getSelectionModel().select(idx);
24038
                                    var frmForm = Ext.ComponentQuery.query('[name=form' + me.name + ']')[0];
24039
                                    //frmDisplay.reset();
24040
                                    frmForm.reset();
24041
                                    frmForm.getForm().setValues(data);
24042
                                    //frmDisplay.setHidden(true);
24043
                                    frmForm.setHidden(false);
24044
                                    btn.fireEvent("click2"); //YN 20220315
24045
                                    //grdPanel.setHidden(true);
24046
                                    //action = "1";                                    
24047
                                }
24048
                            }
24049
                        },
24050
                        {
24051
                            text: 'Delete',
24052
                            hidden: hide_,
24053
                            name: tableName + 'DeleteText',
24054
                            iconCls: 'fa-trash-o',
24055
                            style: 'font-family: FontAwesome',
24056
                            handler: function (btn, e, eOpts) {
24057
                                var grid = Ext.getCmp(gridName);
24058
                                if (grid.deleteFlag === true) {
24059
                                    var me = this,
24060
                                        store = Ext.StoreMgr.lookup(storeID)
24061
                                    var grid = Ext.getCmp(gridName);
24062
                                    Ext.MessageBox.show({
24063
                                        title: 'Remove tab',
24064
                                        msg: "This will remove. Do you want to continue?",
24065
                                        buttons: Ext.MessageBox.YESNO,
24066
                                        fn: function (choice) {
24067
                                            console.log(choice);
24068
                                            if (choice === 'yes') {
24069
                                                var selection = grid.getView().getSelectionModel().getSelection()[0];
24070
                                                if (selection) {
24071
                                                    store.remove(selection);
24072
                                                    btn.fireEvent("click2"); //YN 20220315
24073
                                                }
24074
                                            }
24075
                                        }
24076
                                    });
24077
                                }
24078
                            }
24079
                        },
24080
                        {
24081
                            text: 'Edit',
24082
                            hidden: hide_,
24083
                            name: tableName + 'EditText',
24084
                            bizprocid: me.bizprocid,
24085
                            taskid: me.taskid,
24086
                            TableName: tableName,
24087
                            iconCls: 'fa-edit',
24088
                            style: 'font-family: FontAwesome',
24089
                            handler: function () {
24090
                                ////var frmDisplay = Ext.ComponentQuery.query('[name=display' + me.name + ']')[0];
24091
                                //var grdPanel = Ext.ComponentQuery.query('[name=grid' + me.name + ']')[0];
24092
                                //var dtrec = grdPanel.getView().getSelectionModel().getSelection()[0];
24093
                                //var frmForm = Ext.ComponentQuery.query('[name=form' + me.name + ']')[0];
24094
                                //if (frmForm == undefined) {
24095
                                //    frmForm = Ext.create('MinovaUtil.MinovaES.MinovaWorkflowFormGrid', {
24096
                                //        bizprocid: this.bizprocid,
24097
                                //        taskid: this.taskid,
24098
                                //        name: 'form' + this.TableName,
24099
                                //        tableName: this.TableName,
24100
                                //    });
24101
                                //}
24102
                                ////frmForm.reset();
24103
                                ////frmForm.down('form').getForm().loadRecord(dtrec.data);
24104
                                //frmForm.show();
24105

    
24106
                                var grdPanel = Ext.ComponentQuery.query('[name=grid' + me.name + ']')[0];
24107
                                var dtrec = grdPanel.getView().getSelectionModel().getSelection()[0];
24108
                                var frmForm = Ext.ComponentQuery.query('[name=form' + me.name + ']')[0];
24109
                                if (dtrec) {
24110
                                    //frmDisplay.reset();
24111
                                    frmForm.reset();
24112
                                    frmForm.getForm().setValues(dtrec.data);
24113
                                    //frmDisplay.setHidden(true);
24114
                                    frmForm.setHidden(false);
24115
                                    //grdPanel.setHidden(true);
24116
                                    action = "1";
24117
                                }
24118

    
24119
                                //var grdPanel = Ext.ComponentQuery.query('[name=grid' + me.name + ']')[0];
24120
                                //var dtrec = grdPanel.getView().getSelectionModel().getSelection()[0];
24121
                                //if (dtrec) {
24122
                                //    var pnlT = Ext.ComponentQuery.query('[name=panel' + me.tableNameT + ']')[0];
24123
                                //    var grdPanelT = Ext.ComponentQuery.query('[name=grid' + me.tableNameT + ']')[0];
24124
                                //    var dtrecT = grdPanelT.getStore().filter(me.tableNameTKey, dtrec.data[me.tableNameKey]);
24125
                                //    pnlT.setHidden(false);                                   
24126
                                //}
24127
                            }
24128
                        }
24129
                    ]
24130
                }
24131
                ],
24132
                columns: {
24133
                    defaults: {
24134
                        menuDisabled: true
24135
                    },
24136
                    items: cols
24137
                },
24138
                //selType: checkSelection,
24139
                //plugins: {
24140
                //    ptype: 'actionColumnRowEditing', //rowediting
24141
                //    pluginId: 'rowEditing',
24142
                //    hiddenColumnsOnEdit: ['startEditActionColumn'],
24143
                //    clicksToEdit: 2,
24144
                //    saveButtonIconCls: 'x-fa fa-floppy-o',
24145
                //    listeners: {}
24146
                //},
24147
                listeners: {
24148
                    //'beforeedit': function (editor) {
24149
                    //    editor.getEditor().floatingButtons.items.items[0].hide();
24150
                    //    editor.getEditor().floatingButtons.items.items[1].hide();
24151
                    //}
24152
                    'itemdblclick': function (this_, record, item, index, e, eOpts) {
24153
                        var me = this;
24154
                        var frmForm = Ext.ComponentQuery.query('[name=form' + me.tableName + ']')[0];
24155
                        var grdPanel = Ext.ComponentQuery.query('[name=grid' + me.tableName + ']')[0];
24156
                        var dtrec = record;
24157
                        if (dtrec) {
24158
                            //frmDisplay.reset();
24159
                            //frmForm.reset();
24160
                            frmForm.getForm().setValues(dtrec.data);
24161
                            //grdPanel.setHeight(0);
24162
                            //frmDisplay.setHidden(true);
24163
                            frmForm.setHidden(false);
24164
                            //grdPanel.setHidden(true);
24165

    
24166
                            //var pnlT = Ext.ComponentQuery.query('[name=panel' + me.tableNameT + ']')[0];
24167
                            //var grdPanelT = Ext.ComponentQuery.query('[name=grid' + me.tableNameT + ']')[0];
24168
                            //var dtrecT = grdPanelT.getStore().filter(me.tableNameTKey, dtrec.data[me.tableNameKey]);
24169
                            //pnlT.setTitle('<div style=\"font-size:14px; font-weight: bold;\">Goal ' + dtrec.data[me.tableNameKey] + '-Tasks</div>');
24170
                            //pnlT.setHidden(false);
24171

    
24172
                            action = "1";
24173
                        }
24174
                    },
24175
                    'itemclickx': function (this_, record, item, index, e, eOpts) {
24176
                        var me = this;
24177
                        var frmForm = Ext.ComponentQuery.query('[name=form' + me.tableName + ']')[0];
24178
                        frmForm.setHidden(true);
24179
                        ////var grdPanel = Ext.ComponentQuery.query('[name=grid' + me.tablename + ']')[0];
24180
                        //var dtrec = record;
24181
                        //if (dtrec) {
24182
                        //    //frmDisplay.reset();
24183
                        //    //frmForm.reset();
24184
                        //    frmForm.getForm().setValues(dtrec.data);
24185
                        //    //grdPanel.setHeight(0);
24186
                        //    //frmDisplay.setHidden(true);
24187
                        //    frmForm.setHidden(false);
24188
                        //    //grdPanel.setHidden(true);
24189
                        //    action = "1";
24190
                        //}
24191
                        var grdPanel = Ext.ComponentQuery.query('[name=grid' + me.tableName + ']')[0];
24192
                        var dtrec = grdPanel.getView().getSelectionModel().getSelection()[0];
24193
                        if (dtrec) {
24194
                            var pnlT = Ext.ComponentQuery.query('[name=panel' + me.tableNameT + ']')[0];
24195
                            var grdPanelT = Ext.ComponentQuery.query('[name=grid' + me.tableNameT + ']')[0];
24196
                            var dtrecT = grdPanelT.getStore().filter(me.tableNameTKey, dtrec.data[me.tableNameKey]);
24197
                            pnlT.setTitle('<div style=\"font-size:14px; font-weight: bold;\">Goal ' + dtrec.data[me.tableNameKey] + '-Tasks</div>');
24198
                            pnlT.setHidden(false);
24199
                        }
24200
                    }
24201
                },
24202
                features: features,
24203
                viewConfig: {
24204
                    listeners: {
24205
                        refresh: function (dataview) {
24206
                            Ext.each(dataview.panel.columns, function (column) {
24207
                                column.autoSize();
24208
                                column.setWidth(column.width + 10); //YN 220312
24209
                            })
24210
                        }
24211
                    }
24212
                }
24213
            }
24214
            ]
24215
        });
24216
        me.callParent(arguments);  
24217
    },
24218
    listeners: {
24219
        boxready: function (dataview) {
24220
            var grd = Ext.ComponentQuery.query('[name=grid' + this.tableName + ']')[0];
24221
            grd.reconfigure(); //YN 20211217 - Solusi Layout rapih
24222
        }
24223
    }
24224
});
24225

    
24226
/*NonEditableGridT ESS Generator YN 20211216 */
24227
Ext.define('MinovaUtil.MinovaES.MinovaWorkflowNonEditableGridT', {
24228
    extend: 'Ext.form.Panel',
24229
    alias: ['widget.minovaworkflownoneditablegridT'],
24230
    requires: [
24231
        'Ext.grid.plugin.CellEditing',
24232
        'Ext.grid.RowNumberer',
24233
        'Ext.grid.Panel',
24234
    ],
24235
    anchor: '100%',
24236
    tableName: undefined,
24237
    tableNameP: undefined,
24238
    tableNameKey: undefined,
24239
    tableNameFKey: undefined,
24240
    tableNamePKey: undefined,
24241
    parentKey: undefined,
24242
    hideButton: undefined,
24243
    multiSelect: undefined,
24244
    formname: this.name,
24245
    bizprocid: undefined,
24246
    bizflowid: undefined,
24247
    taskid: undefined,
24248
    features: undefined,
24249
    height: 400,
24250
    minHeight: 20,
24251
    maxHeight: 400,
24252
    initComponent: function () {
24253
        var me = this;
24254
        var isLookup = me.isLookup;
24255
        var hide_ = false;
24256
        var widthLock = 250;
24257
        var checkSelection = '';
24258
        if (me.hideButton == true) {
24259
            hide_ = true;
24260
        }
24261
        if (me.multiSelect) {
24262
            locking = false;
24263
            checkSelection = 'checkboxmodel';
24264
            widthLock = 40;
24265
        }
24266
        var tableName = me.tableName;
24267
        var features = me.features;
24268
        var cols = [];
24269
        var fieldStore = [];
24270
        var _url = 'GetAllField';
24271
        var hasil = null;
24272
        var height = me.height;
24273
        var storeID = 'store' + me.tableName + '_' + me.parentKey;
24274
        var gridName = 'grid' + me.name;
24275
        if (me.storeName) {
24276
            storeID = me.storeName;
24277
        }
24278
        var LangID = MinovaUtil.GetLangID();
24279
        var parameter = "LangID='" + LangID + "',BizProcessID='" + me.bizprocid + "',TaskID='" + me.taskid + "',TableName='" + me.tableName + "'";
24280
        Ext.Ajax.request({
24281
            async: false,
24282
            method: 'POST',
24283
            url: '/UserControl/GetStore',
24284
            params: {
24285
                tableName: 'PDSWFSTRUCTUREFIELD',
24286
                param: parameter
24287
            },
24288
            success: function (response) {
24289
                var results = Ext.decode(response.responseText);
24290
                hasil = results.data;
24291
            }
24292
        });
24293
        //cols.push({
24294
        //    xtype: 'rownumberer'
24295
        //});
24296
        var addData = 'var data={';
24297
        if (hasil.length > 0) {
24298
            Ext.each(hasil, function (rec) {
24299
                fieldStore.push(rec.FieldName);
24300
                if (rec.FieldName != 'Sequence') {
24301
                    addData = addData + rec.FieldName + ":" + "'',";
24302
                }
24303
                var null_ = null;
24304
                var ReadOnly_ = false;
24305
                if (rec.IsRequired == '1') {
24306
                    null_ = false;
24307
                } else {
24308
                    null_ = true;
24309
                }
24310
                var Hidden_ = false;
24311
                if (rec.IsReadOnly == '1') {
24312
                    ReadOnly_ = true;
24313
                }
24314
                if (rec.IsVisible == '1') {
24315
                    switch (rec.FormatRef) {
24316
                        case "date":
24317
                            cols.push({
24318
                                xtype: 'minovadatecolumn',
24319
                                hidden: Hidden_,
24320
                                text: rec.HeaderTitle,
24321
                                dataIndex: rec.FieldName,
24322
                                filter: {
24323
                                    itemDefaults: {
24324
                                        emptyText: 'Search for...',
24325
                                    }
24326
                                }
24327
                            });
24328
                            break
24329
                        case "amount":
24330
                            cols.push({
24331
                                xtype: 'minovacurrancycolumn',
24332
                                align: 'right',
24333
                                text: rec.HeaderTitle,
24334
                                dataIndex: rec.FieldName,
24335
                                hidden: Hidden_,
24336
                                filter: {
24337
                                    itemDefaults: {
24338
                                        emptyText: 'Search for...'
24339
                                    }
24340
                                }
24341
                            });
24342
                            break
24343
                        default:
24344
                            if (rec.DataRef == 'CREATEBY' || rec.DataRef == 'CHANGEBY' || rec.DataRef == 'CREATEDT' || rec.DataRef == 'CHANGEDT') {
24345
                                cols.push({
24346
                                    text: rec.HeaderTitle,
24347
                                    dataIndex: rec.FieldName,
24348
                                    width: 100,
24349
                                    filter: {
24350
                                        type: 'string',
24351
                                        itemDefaults: {
24352
                                            emptyText: 'Search for...'
24353
                                        }
24354
                                    }
24355
                                });
24356
                            } else if (rec.SearchType == '0') {
24357
                                var valueField = null;
24358
                                var displayValue = null;
24359
                                var TableRef = undefined;
24360
                                if (rec.TableRef != '') {
24361
                                    TableRef = rec.TableRef;
24362
                                    Ext.Ajax.request({
24363
                                        async: false,
24364
                                        method: 'POST',
24365
                                        url: '/UserControl/GetStore',
24366
                                        params: {
24367
                                            tableName: 'SDATATABLEFIELD',
24368
                                            param: 'TableName[equal]' + rec.TableRef
24369
                                        },
24370
                                        success: function (response) {
24371
                                            var results = Ext.decode(response.responseText);
24372
                                            data_ = results.data;
24373
                                            if (data_ != undefined) {
24374
                                                valueField_ = $.grep(data_, function (r) {
24375
                                                    return r.ValueField == '1'
24376
                                                });
24377
                                                valueField = valueField_[0].FieldName
24378
                                                displayValue_ = $.grep(data_, function (r) {
24379
                                                    return r.DisplayValue == '1'
24380
                                                });
24381
                                                displayValue = displayValue_[0].FieldName
24382
                                            }
24383
                                        }
24384
                                    });
24385
                                }
24386
                                Ext.create('Ext.data.Store', {
24387
                                    storeId: 'store_' + me.tableName + rec.FieldName,
24388
                                    autoLoad: true,
24389
                                    proxy: {
24390
                                        method: 'POST',
24391
                                        type: 'ajax',
24392
                                        url: '/UserControl/GetStoreAuth',
24393
                                        extraParams: {
24394
                                            tableName: TableRef,
24395
                                            param: rec.ParamCombo,
24396
                                            menuId: MinovaUtil.GetMenuID()
24397
                                        },
24398
                                        reader: {
24399
                                            type: 'json',
24400
                                            root: 'data',
24401
                                            totalProperty: 'data[0].TotalCount'
24402
                                        }
24403
                                    }
24404
                                });
24405
                                cols.push({
24406
                                    //xtype : 'minovacombocolumn',
24407
                                    hidden: Hidden_,
24408
                                    text: rec.HeaderTitle,
24409
                                    dataIndex: rec.FieldName,
24410
                                    width: (rec.Length * 6.5 + 20) > 300 ? 300 : rec.Length * 6.5 + 30,
24411
                                    //valueField : valueField,
24412
                                    //displayField : displayValue,
24413
                                    //store : 'store_' + me.tableName + rec.FieldName,
24414
                                    renderer: function (value) {
24415
                                        var store = Ext.data.StoreManager.lookup('store_' + me.tableName + rec.FieldName);
24416
                                        var index = store.find(valueField, value);
24417
                                        var val = "";
24418
                                        if (index != -1) {
24419
                                            var rc = store.getAt(index);
24420
                                            val = rc.get(displayValue);
24421
                                        } else {
24422
                                            val = value;
24423
                                        }
24424
                                        return val;
24425
                                    },
24426
                                    filter: {
24427
                                        type: 'list',
24428
                                        itemDefaults: {
24429
                                            emptyText: 'Search for...'
24430
                                        }
24431
                                    }
24432
                                });
24433
                            } else if (rec.SearchType == '5') {
24434
                                var valueField = null;
24435
                                var displayValue = null;
24436
                                var AdditionaldisplayValue = null;
24437
                                var TableRef = undefined;
24438
                                if (rec.TableRef != '') {
24439
                                    TableRef = rec.TableRef;
24440
                                    Ext.Ajax.request({
24441
                                        async: false,
24442
                                        method: 'POST',
24443
                                        url: '/UserControl/GetStore',
24444
                                        params: {
24445
                                            tableName: 'SDATATABLEFIELD',
24446
                                            param: 'TableName[equal]' + rec.TableRef
24447
                                        },
24448
                                        success: function (response) {
24449
                                            var results = Ext.decode(response.responseText);
24450
                                            data_ = results.data;
24451
                                            if (data_ != undefined) {
24452
                                                valueField_ = $.grep(data_, function (r) {
24453
                                                    return r.ValueField == '1'
24454
                                                });
24455
                                                if (valueField_.length > 0) {
24456
                                                    valueField = valueField_[0].FieldName
24457
                                                }
24458

    
24459
                                                displayValue_ = $.grep(data_, function (r) {
24460
                                                    return r.DisplayValue == '1' || r.DisplayValue == '2'
24461
                                                });
24462
                                                if (displayValue_.length > 0) {
24463
                                                    displayValue = displayValue_[0].FieldName;
24464
                                                }
24465
                                                if (displayValue_.length >= 2) {
24466
                                                    AdditionaldisplayValue = displayValue_[1].FieldName
24467
                                                }
24468
                                            }
24469
                                        }
24470
                                    });
24471
                                }
24472
                                Ext.create('Ext.data.Store', {
24473
                                    storeId: 'store_' + me.tableName + rec.FieldName,
24474
                                    autoLoad: true,
24475
                                    proxy: {
24476
                                        method: 'POST',
24477
                                        type: 'ajax',
24478
                                        url: '/UserControl/GetStoreAuth',
24479
                                        extraParams: {
24480
                                            tableName: TableRef,
24481
                                            param: rec.ParamCombo,
24482
                                            menuId: MinovaUtil.GetMenuID()
24483
                                        },
24484
                                        reader: {
24485
                                            type: 'json',
24486
                                            root: 'data',
24487
                                            totalProperty: 'data[0].TotalCount'
24488
                                        }
24489
                                    }
24490
                                });
24491
                                cols.push({
24492
                                    //xtype : 'minovacombocolumn',
24493
                                    hidden: Hidden_,
24494
                                    text: rec.HeaderTitle,
24495
                                    dataIndex: rec.FieldName,
24496
                                    //valueField : valueField,
24497
                                    //displayField : displayValue,
24498
                                    //store : 'store_' + me.tableName + rec.FieldName,
24499
                                    tpl: Ext.create('Ext.XTemplate',
24500
                                        '<ul class="x-list-plain"><tpl for=".">',
24501
                                        '<li role="option" class="x-boundlist-item">{' + AdditionaldisplayValue + '} - {' + displayValue + '}</li>',
24502
                                        '</tpl></ul>'),
24503
                                    displayTpl: Ext.create('Ext.XTemplate',
24504
                                        '<tpl for=".">',
24505
                                        '{' + AdditionaldisplayValue + '} - {' + displayValue + '}',
24506
                                        '</tpl>'),
24507
                                    renderer: function (value) {
24508
                                        var store = Ext.data.StoreManager.lookup('store_' + me.tableName + rec.FieldName);
24509
                                        var index = store.find(valueField, value);
24510
                                        var val = "";
24511
                                        if (index != -1) {
24512
                                            var rc = store.getAt(index);
24513
                                            //val = rc.get(displayValue);
24514
                                            val = rc.get(AdditionaldisplayValue) + ' - ' + rc.get(displayValue);
24515
                                        } else {
24516
                                            val = value;
24517
                                        }
24518
                                        return val;
24519
                                    },
24520
                                    filter: {
24521
                                        type: 'list',
24522
                                        itemDefaults: {
24523
                                            emptyText: 'Search for...'
24524
                                        }
24525
                                    }
24526
                                });
24527
                            } else if (rec.SearchType == '2') {
24528
                                var triger = (rec.TriggerCombo).split('$');
24529
                                var targetField_ = triger[0];
24530
                                var fieldValue_ = triger[1];
24531
                                cols.push({
24532
                                    text: rec.HeaderTitle,
24533
                                    hidden: Hidden_,
24534
                                    dataIndex: rec.FieldName,
24535
                                    filter: {
24536
                                        itemDefaults: {
24537
                                            emptyText: 'Search for...'
24538
                                        }
24539
                                    }
24540
                                });
24541
                            } else if (rec.SearchType == '3') {
24542
                                cols.push({
24543
                                    text: rec.HeaderTitle,
24544
                                    hidden: Hidden_,
24545
                                    dataIndex: rec.FieldName,
24546
                                    filter: {
24547
                                        itemDefaults: {
24548
                                            emptyText: 'Search for...'
24549
                                        }
24550
                                    }
24551
                                });
24552
                            } else if (rec.SearchType != '0' && rec.SearchType != '1' && rec.SearchType != '3' && (rec.FieldName == 'EmployeeID' || rec.FieldName == 'ApplicantID' || rec.FieldName == 'EmployeeIDFrom' || rec.FieldName == 'EmployeeIDTo') && isLookup != true) {
24553
                                var triger = (rec.TriggerCombo).split('&');
24554
                                var targetField_ = triger[0];
24555
                                var fieldValue_ = triger[0];
24556
                                cols.push({
24557
                                    text: rec.HeaderTitle,
24558
                                    hidden: Hidden_,
24559
                                    dataIndex: rec.FieldName,
24560
                                    filter: {
24561
                                        itemDefaults: {
24562
                                            emptyText: 'Search for...'
24563
                                        }
24564
                                    }
24565
                                });
24566
                            } else if (rec.SearchType == '4' && isLookup != true) {
24567
                                cols.push({
24568
                                    text: rec.HeaderTitle,
24569
                                    hidden: Hidden_,
24570
                                    dataIndex: rec.FieldName,
24571
                                    filter: {
24572
                                        itemDefaults: {
24573
                                            emptyText: 'Search for...'
24574
                                        }
24575
                                    }
24576
                                });
24577
                            } else if (rec.FixedValue != '') { // add by taufan
24578
                                cols.push({
24579
                                    text: rec.HeaderTitle,
24580
                                    hidden: Hidden_,
24581
                                    dataIndex: rec.FieldName,
24582
                                    filter: {
24583
                                        itemDefaults: {
24584
                                            emptyText: 'Search for...'
24585
                                        }
24586
                                    },
24587
                                    renderer: function (value) {
24588
                                        var val = "";
24589
                                        var storeData = [];
24590
                                        var str = rec.FixedValue;
24591
                                        var hasil = str.split('||');
24592
                                        hasil.forEach(function (h) {
24593
                                            store_ = h.split('=')
24594
                                            storeData.push({
24595
                                                code: store_[0],
24596
                                                desc: store_[1]
24597
                                            });
24598
                                        });
24599
                                        var item = storeData.find(x => x.code == value);
24600
                                        if (item != undefined) {
24601
                                            val = item.desc;
24602
                                        }
24603
                                        return val;
24604
                                    }
24605
                                });
24606
                            } else {
24607
                                _xtype = 'textfield';
24608
                                if (rec.Length > 250) {
24609
                                    _xtype = 'textareafield';
24610
                                }
24611
                                var _custumFunc = null;
24612
                                Ext.Ajax.request({
24613
                                    async: false,
24614
                                    method: 'POST',
24615
                                    url: '/UserControl/GetStore',
24616
                                    params: {
24617
                                        tableName: 'SDATATABLEFIELD',
24618
                                        param: 'FieldName[equal]' + rec.FieldName + ',TableName[equal]' + me.tableName
24619
                                    },
24620
                                    success: function (response) {
24621
                                        var results = Ext.decode(response.responseText);
24622
                                        data_ = results.data[0];
24623
                                        if (data_ != undefined) {
24624
                                            _custumFunc = data_.SelectFunction;
24625
                                        }
24626
                                    }
24627
                                });
24628
                                cols.push({
24629
                                    text: rec.HeaderTitle,
24630
                                    xtype: 'gridcolumn',
24631
                                    hidden: Hidden_,
24632
                                    dataIndex: rec.FieldName,
24633
                                    filter: {
24634
                                        itemDefaults: {
24635
                                            emptyText: 'Search for...'
24636
                                        }
24637
                                    },
24638
                                    cellWrap: true,
24639
                                    width: (rec.Length * 8) > 400 ? 400 : rec.Length * 8,
24640
                                    renderer: function (v) {
24641
                                        result = v.replace(/\r\n\r\n/g, "</p><p>").replace(/\n\n/g, "</p><p>");
24642
                                        result = result.replace(/\r\n/g, "<br />").replace(/\n/g, "<br />");
24643
                                        return result
24644
                                    }
24645
                                });
24646
                            }
24647
                            break
24648
                    }
24649
                } else {
24650
                    cols.push({
24651
                        text: rec.HeaderTitle,
24652
                        hidden: Hidden_,
24653
                        dataIndex: rec.FieldName,
24654
                        hidden: true,
24655
                        filter: {
24656
                            itemDefaults: {
24657
                                emptyText: 'Search for...'
24658
                            }
24659
                        }
24660
                    });
24661
                }
24662
            });
24663

    
24664
        };
24665

    
24666
        addData = addData + "}";
24667
        Ext.applyIf(me, {
24668
            items: [{
24669
                xtype: 'grid',
24670
                id: gridName,
24671
                name: gridName,
24672
                tablename: me.tableName,
24673
                minHeight: me.minHeight,
24674
                maxHeight: me.maxHeight,
24675
                addFlag: true,
24676
                deleteFlag: true,
24677
                store: Ext.create('Ext.data.Store', {
24678
                    storeId: storeID,
24679
                    fields: fieldStore,
24680
                    //groupField: 'QuestionGroup',
24681
                    grouper: {
24682
                        sortProperty: 'SeqQuest',
24683
                        groupFn: function (record) {
24684
                            return record.get('QuestionGroup');
24685
                        }
24686
                    },
24687
                    proxy: {
24688
                        method: 'POST',
24689
                        type: 'ajax',
24690
                        url: '',
24691
                        reader: {
24692
                            type: 'json',
24693
                            root: 'data'
24694
                        }
24695
                    }
24696
                }),
24697
                dockedItems: [{
24698
                    xtype: 'toolbar',
24699
                    items: [
24700
                        {
24701
                            text: 'Add',
24702
                            hidden: hide_,
24703
                            name: tableName + 'Add',
24704
                            iconCls: 'fa-plus-circle',
24705
                            style: 'font-family: FontAwesome',
24706
                            handler: function () {
24707
                                var grid = Ext.getCmp(gridName);
24708
                                if (grid.addFlag === true) {
24709
                                    var store = Ext.StoreMgr.lookup(storeID)
24710
                                    idx = store.getCount();
24711
                                    var action = getParam('action');
24712
                                    var data = '';
24713
                                    var Sequence = 0;
24714
                                    if (idx == 0) {
24715
                                        Sequence = 1;
24716
                                    } else {
24717
                                        Sequence = 1 + idx;
24718
                                    }
24719
                                    var seq = 'Sequence';
24720
                                    var SequenceValue = Sequence;
24721
                                    eval(addData);
24722
                                    var grdParent = Ext.ComponentQuery.query('[name=grid' + me.tableNameP + ']')[0];
24723
                                    var dtParent = grdParent.getView().getSelectionModel().getSelection()[0];
24724
                                    if (dtParent == undefined) {
24725
                                        grdParent.getView().getSelectionModel().select(0);
24726
                                        dtParent = grdParent.getView().getSelectionModel().getSelection()[0];
24727
                                    }
24728
                                    data[seq] = SequenceValue;
24729
                                    data[me.tableNameFKey] = dtParent.data[me.tableNamePKey];
24730
                                    data[me.tableNameKey] = SequenceValue.toString();
24731
                                    store.insert(idx, data);
24732
                                    grid.getView().getSelectionModel().select(idx);
24733
                                    var frmForm = Ext.ComponentQuery.query('[name=form' + me.name + ']')[0];
24734
                                    frmForm.reset();
24735
                                    frmForm.getForm().setValues(data);
24736
                                    //frmDisplay.setHidden(true);
24737
                                    frmForm.setHidden(false);
24738
                                }
24739
                            }
24740
                        },
24741
                        {
24742
                            text: 'Delete',
24743
                            hidden: hide_,
24744
                            name: tableName + 'DeleteText',
24745
                            iconCls: 'fa-trash-o',
24746
                            style: 'font-family: FontAwesome',
24747
                            handler: function () {
24748
                                var grid = Ext.getCmp(gridName);
24749
                                if (grid.deleteFlag === true) {
24750
                                    //var me = this,
24751
                                    store = Ext.StoreMgr.lookup(storeID)
24752
                                    var grid = Ext.getCmp(gridName);
24753
                                    Ext.MessageBox.show({
24754
                                        title: 'Remove tab',
24755
                                        msg: "This will remove. Do you want to continue?",
24756
                                        buttons: Ext.MessageBox.YESNO,
24757
                                        fn: function (choice) {
24758
                                            console.log(choice);
24759
                                            if (choice === 'yes') {
24760
                                                var selection = grid.getView().getSelectionModel().getSelection()[0];
24761
                                                if (selection) {
24762
                                                    store.remove(selection);
24763
                                                    var frmForm = Ext.ComponentQuery.query('[name=form' + me.name + ']')[0];
24764
                                                    frmForm.reset();
24765
                                                    //frmDisplay.setHidden(true);
24766
                                                    frmForm.setHidden(true);
24767
                                                }
24768
                                            }
24769
                                        }
24770
                                    });
24771
                                }
24772
                            }
24773
                        },
24774
                        {
24775
                            text: 'Edit',
24776
                            hidden: hide_,
24777
                            name: tableName + 'EditText',
24778
                            bizprocid: me.bizprocid,
24779
                            taskid: me.taskid,
24780
                            TableName: tableName,
24781
                            iconCls: 'fa-edit',
24782
                            style: 'font-family: FontAwesome',
24783
                            handler: function () {
24784
                                ////var frmDisplay = Ext.ComponentQuery.query('[name=display' + me.name + ']')[0];
24785
                                //var grdPanel = Ext.ComponentQuery.query('[name=grid' + me.name + ']')[0];
24786
                                //var dtrec = grdPanel.getView().getSelectionModel().getSelection()[0];
24787
                                //var frmForm = Ext.ComponentQuery.query('[name=form' + me.name + ']')[0];
24788
                                //if (frmForm == undefined) {
24789
                                //    frmForm = Ext.create('MinovaUtil.MinovaES.MinovaWorkflowFormGrid', {
24790
                                //        bizprocid: this.bizprocid,
24791
                                //        taskid: this.taskid,
24792
                                //        name: 'form' + this.TableName,
24793
                                //        tableName: this.TableName,
24794
                                //    });
24795
                                //}
24796
                                ////frmForm.reset();
24797
                                ////frmForm.down('form').getForm().loadRecord(dtrec.data);
24798
                                //frmForm.show();
24799

    
24800
                                var grdPanel = Ext.ComponentQuery.query('[name=grid' + me.name + ']')[0];
24801
                                var dtrec = grdPanel.getView().getSelectionModel().getSelection()[0];
24802
                                var frmForm = Ext.ComponentQuery.query('[name=form' + me.name + ']')[0];
24803
                                if (dtrec) {
24804
                                    //frmDisplay.reset();
24805
                                    frmForm.reset();
24806
                                    frmForm.getForm().setValues(dtrec.data);
24807
                                    //frmDisplay.setHidden(true);
24808
                                    frmForm.setHidden(false);
24809
                                    //grdPanel.setHidden(true);
24810
                                    action = "1";
24811
                                }
24812
                            }
24813
                        }
24814
                    ]
24815
                }
24816
                ],
24817
                columns: cols,
24818
                //selType: checkSelection,
24819
                //plugins: {
24820
                //    ptype: 'actionColumnRowEditing', //rowediting
24821
                //    pluginId: 'rowEditing',
24822
                //    hiddenColumnsOnEdit: ['startEditActionColumn'],
24823
                //    clicksToEdit: 2,
24824
                //    saveButtonIconCls: 'x-fa fa-floppy-o',
24825
                //    listeners: {}
24826
                //},
24827
                listeners: {
24828
                    //'beforeedit': function (editor) {
24829
                    //    editor.getEditor().floatingButtons.items.items[0].hide();
24830
                    //    editor.getEditor().floatingButtons.items.items[1].hide();
24831
                    //}
24832
                    'itemdblclick': function (this_, record, item, index, e, eOpts) {
24833
                        //var me = this;
24834
                        var frmForm = Ext.ComponentQuery.query('[name=form' + me.name + ']')[0];
24835
                        //var grdPanel = Ext.ComponentQuery.query('[name=grid' + me.tablename + ']')[0];
24836
                        var dtrec = record;
24837
                        if (dtrec) {
24838
                            //frmDisplay.reset();
24839
                            //frmForm.reset();
24840
                            frmForm.getForm().setValues(dtrec.data);
24841
                            //grdPanel.setHeight(0);
24842
                            //frmDisplay.setHidden(true);
24843
                            frmForm.setHidden(false);
24844
                            //grdPanel.setHidden(true);
24845
                            action = "1";
24846
                        }
24847
                    }
24848
                },
24849
                features: features,
24850
                viewConfig: {
24851
                    listeners: {
24852
                        refresh: function (dataview) {
24853
                            Ext.each(dataview.panel.columns, function (column) {
24854
                                //column.autoSize();
24855
                            })
24856
                        }
24857
                    }
24858
                }
24859
            }
24860
            ]
24861
        });
24862
        me.callParent(arguments);
24863
    },
24864
    listeners: {
24865
        boxready: function (dataview) {
24866
            var grd = Ext.ComponentQuery.query('[name=grid' + this.name + ']')[0];
24867
            grd.reconfigure(); //YN 20211217 - Solusi Layout rapih
24868
        }
24869
    }
24870
});
24871

    
24872
/*Form ESS Generator YN 20211216*/
24873
Ext.define('MinovaUtil.MinovaES.MinovaWorkflowFormGrid', {
24874
    extend: 'Ext.form.Panel',
24875
    alias: ['widget.MinovaWorkflowFormGrid', 'widget.minovaworkflowformgrid', 'widget.workflowformgrid'],
24876
    controller: 'workflowformgrid',
24877
    formname: this.name,
24878
    bizprocid: undefined,
24879
    bizflowid: undefined,
24880
    taskid: undefined,
24881
    tableName: undefined,
24882
    tableNameT: undefined,
24883
    titleform: undefined,
24884
    labelWidth: 150,
24885
    //resizable: true,
24886
    border: true,
24887
    autoScroll: true,
24888
    minHeight: 20,
24889
    layout: {
24890
        type: 'hbox'
24891
    },
24892
    listeners: {
24893
        render: function () {
24894
            if (this.titleform != undefined) {
24895
                this.setTitle(this.titleform);
24896
            }
24897
        },
24898
    },
24899
    buttonAlign: 'left',
24900
    defaults: {
24901
        layout: 'anchor',
24902
        xtype: 'container',
24903
        flex: 1,
24904
        margin: '10px',
24905
        //defaultType: 'textfield',
24906
        //anchor: '100%',
24907
        ////style: 'width: 50%',
24908
    },
24909
    initComponent: function () {
24910
        var col1 = [];
24911
        var col2 = [];
24912
        var me = this;
24913
        var LangID = localStorage.LangId;
24914
        var parameter = "LangID='" + LangID + "',BizProcessID='" + me.bizprocid + "',TaskID='" + me.taskid + "',TableName='" + me.tableName + "'";
24915
        var formname_ = me.name;
24916
        var nameTable_ = me.tableName;
24917
        //var labelWidth = 150;
24918
        Ext.Ajax.request({
24919
            async: false,
24920
            method: 'POST',
24921
            url: '/UserControl/GetStore',
24922
            params: {
24923
                tableName: 'PDSWFSTRUCTUREFIELD',
24924
                param: parameter
24925
            },
24926
            success: function (response) {
24927
                var results = Ext.decode(response.responseText);
24928
                hasil = results.data;
24929
            }
24930
        });
24931
        if (hasil.length > 0) {
24932
            Ext.each(hasil, function (rec) {
24933
                var formfield = undefined;
24934
                var readonly = false;
24935
                var ishidden = false;
24936
                var allowblank = true;
24937
                var startDt = null;
24938
                var endDt = null;
24939
                if (rec.FieldName == 'StartDate' || rec.FieldName == 'EndDate') {
24940
                    startDt = 'StartDate';
24941
                    endDt = 'EndDate';
24942
                }
24943
                if (rec.IsReadOnly == '1') {
24944
                    readonly = true;
24945
                }
24946
                if (rec.IsRequired == '1') {
24947
                    allowblank = false;
24948
                }
24949
                if (rec.IsVisible == '0') {
24950
                    ishidden = true;
24951
                }
24952
                if (rec.SearchType == "") //textfield
24953
                {
24954
                    switch (rec.FormatRef) {
24955
                        case "date":
24956
                            if (rec.FieldName == 'StartDate' || rec.FieldName == 'EndDate') {
24957
                                formfield = new Ext.form.DateField({
24958
                                    allowBlank: allowblank,
24959
                                    fieldLabel: rec.ScreenCaption,
24960
                                    readOnly: readonly,
24961
                                    msgTarget: 'side',
24962
                                    //labelCls: 'label-minova',
24963
                                    labelWidth: me.labelWidth,
24964
                                    hidden: ishidden,
24965
                                    name: rec.FieldName,
24966
                                    submitFormat: 'Ymd',
24967
                                    value: rec.DefaultValue,
24968
                                    anchor: '100%',
24969
                                    vtype: 'daterange',
24970
                                    start: startDt,
24971
                                    end: endDt,
24972
                                    formname: formname_,
24973
                                    nameTable: nameTable_,
24974
                                    hideMode: 'visibility',
24975
                                    listeners: {
24976
                                        change: function (val) {
24977
                                            var _label = val.name;
24978
                                            var _form = val.formname;
24979
                                            var _Value = val.getValue();
24980
                                            var target = rec.TriggerCombo;
24981
                                            var custumFunc = rec.SelectFunction;
24982
                                            if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
24983
                                                Ext.Ajax.request({
24984
                                                    async: false,
24985
                                                    method: 'POST',
24986
                                                    url: '/UserControl/GetStore',
24987
                                                    params: {
24988
                                                        tableName: 'PCMFUNC',
24989
                                                        param: 'FuncName[equal]' + rec.custumFunc + ',Active[=]1'
24990
                                                    },
24991
                                                    success: function (response) {
24992
                                                        var results = Ext.decode(response.responseText);
24993
                                                        data_ = results.data[0];
24994
                                                        if (data_ != undefined) {
24995
                                                            custumFunc = data_.FunctionCode;
24996
                                                        }
24997
                                                    }
24998
                                                });
24999
                                            }
25000
                                            var frm = Ext.ComponentQuery.query('form[name=' + _form + ']')[0];
25001
                                            if (frm) {
25002
                                                if (custumFunc) {
25003
                                                    eval(custumFunc)
25004
                                                }
25005
                                            }
25006
                                        }
25007
                                    }
25008
                                });
25009
                            } else {
25010
                                formfield = new Ext.form.DateField({
25011
                                    allowBlank: allowblank,
25012
                                    fieldLabel: rec.ScreenCaption,
25013
                                    readOnly: readonly,
25014
                                    msgTarget: 'side',
25015
                                    //labelCls: 'label-minova',
25016
                                    labelWidth: me.labelWidth,
25017
                                    hidden: ishidden,
25018
                                    name: rec.FieldName,
25019
                                    submitFormat: 'Ymd',
25020
                                    value: rec.DefaultValue,
25021
                                    anchor: '100%',
25022
                                    formname: formname_,
25023
                                    nameTable: nameTable_,
25024
                                    hideMode: 'visibility',
25025
                                    listeners: {
25026
                                        change: function (val) {
25027
                                            var _label = val.name;
25028
                                            var _form = val.formname;
25029
                                            var _Value = val.getValue();
25030
                                            var target = rec.TriggerCombo;
25031
                                            var custumFunc = rec.SelectFunction;
25032
                                            if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
25033
                                                Ext.Ajax.request({
25034
                                                    async: false,
25035
                                                    method: 'POST',
25036
                                                    url: '/UserControl/GetStore',
25037
                                                    params: {
25038
                                                        tableName: 'PCMFUNC',
25039
                                                        param: 'FuncName[equal]' + rec.custumFunc + ',Active[=]1'
25040
                                                    },
25041
                                                    success: function (response) {
25042
                                                        var results = Ext.decode(response.responseText);
25043
                                                        data_ = results.data[0];
25044
                                                        if (data_ != undefined) {
25045
                                                            custumFunc = data_.FunctionCode;
25046
                                                        }
25047
                                                    }
25048
                                                });
25049
                                            }
25050
                                            var frm = Ext.ComponentQuery.query('form[name=' + _form + ']')[0];
25051
                                            if (frm) {
25052
                                                if (custumFunc) {
25053
                                                    eval(custumFunc)
25054
                                                }
25055
                                            }
25056
                                        }
25057
                                    }
25058
                                });
25059
                            }
25060
                            break;
25061
                        case "time":
25062
                            formfield = new Ext.form.TimeField({
25063
                                allowBlank: allowblank,
25064
                                fieldLabel: rec.ScreenCaption,
25065
                                readOnly: readonly,
25066
                                //labelCls: 'label-minova',
25067
                                labelWidth: me.labelWidth,
25068
                                hidden: ishidden,
25069
                                name: rec.FieldName,
25070
                                msgTarget: 'side',
25071
                                format: 'Hi',
25072
                                submitFormat: 'Hi',
25073
                                increment: 5,
25074
                                value: rec.DefaultValue,
25075
                                anchor: '100%',
25076
                                formname: formname_,
25077
                                nameTable: nameTable_,
25078
                                listeners: {
25079
                                    change: function (val) {
25080
                                        var _label = val.name;
25081
                                        var _form = val.formname;
25082
                                        var _Value = val.getValue();
25083
                                        var target = rec.TriggerCombo;
25084
                                        var custumFunc = rec.SelectFunction;
25085
                                        if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
25086
                                            Ext.Ajax.request({
25087
                                                async: false,
25088
                                                method: 'POST',
25089
                                                url: '/UserControl/GetStore',
25090
                                                params: {
25091
                                                    tableName: 'PCMFUNC',
25092
                                                    param: 'FuncName[equal]' + custumFunc + ',Active[=]1'
25093
                                                },
25094
                                                success: function (response) {
25095
                                                    var results = Ext.decode(response.responseText);
25096
                                                    data_ = results.data[0];
25097
                                                    if (data_ != undefined) {
25098
                                                        custumFunc = data_.FunctionCode;
25099
                                                    }
25100
                                                }
25101
                                            });
25102
                                        }
25103
                                        var frm = Ext.ComponentQuery.query('form[name=' + _form + ']')[0];
25104
                                        if (frm) {
25105
                                            if (custumFunc) {
25106
                                                eval(custumFunc)
25107
                                            }
25108
                                        }
25109
                                    }
25110
                                }
25111
                            });
25112
                            break;
25113
                        case "amount":
25114
                            formfield = new Ext.form.TextField({
25115
                                allowBlank: allowblank,
25116
                                fieldLabel: rec.ScreenCaption,
25117
                                readOnly: readonly,
25118
                                //labelCls: 'label-minova',
25119
                                labelWidth: me.labelWidth,
25120
                                hidden: ishidden,
25121
                                name: rec.FieldName,
25122
                                msgTarget: 'side',
25123
                                value: rec.DefaultValue,
25124
                                maxLength: rec.Length,
25125
                                anchor: '100%',
25126
                                formname: formname_,
25127
                                nameTable: nameTable_,
25128
                                fieldStyle: 'text-align:right;',
25129
                                listeners: {
25130
                                    change: function (val) {
25131
                                        var _label = val.name;
25132
                                        var _form = val.formname;
25133
                                        var _Value = val.getValue();
25134
                                        var target = rec.TriggerCombo;
25135
                                        var custumFunc = rec.SelectFunction;
25136
                                        if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
25137
                                            Ext.Ajax.request({
25138
                                                async: false,
25139
                                                method: 'POST',
25140
                                                url: '/UserControl/GetStore',
25141
                                                params: {
25142
                                                    tableName: 'PCMFUNC',
25143
                                                    param: 'FuncName[equal]' + rec.custumFunc + ',Active[=]1'
25144
                                                },
25145
                                                success: function (response) {
25146
                                                    var results = Ext.decode(response.responseText);
25147
                                                    data_ = results.data[0];
25148
                                                    if (data_ != undefined) {
25149
                                                        custumFunc = data_.FunctionCode;
25150
                                                    }
25151
                                                }
25152
                                            });
25153
                                        }
25154
                                        var frm = Ext.ComponentQuery.query('form[name=' + _form + ']')[0];
25155
                                        if (frm) {
25156
                                            if (custumFunc) {
25157
                                                eval(custumFunc)
25158
                                            }
25159
                                        }
25160
                                    }
25161
                                }
25162
                            });
25163
                            break;
25164
                        case "file":
25165
                            formfield = new MinovaUtil.MinovaES.UploadFile({
25166
                                allowBlank: allowblank,
25167
                                fieldLabel: rec.ScreenCaption,
25168
                                readOnly: readonly,
25169
                                readOnlyCls: 'minova-readonly',
25170
                                hidden: ishidden,
25171
                                //labelCls: 'label-minova',
25172
                                name: rec.FieldName,
25173
                                msgTarget: 'side',
25174
                                fieldname: rec.FieldName,
25175
                                IsPrimaryKey: rec.IsPrimaryKey,
25176
                                tableName: rec.TableRef,
25177
                                triggerCls: 'x-form-search-trigger',
25178
                                formtarget: me.formname,
25179
                                anchor: '100%',
25180
                                formname: formname_,
25181
                                nameTable: nameTable_,
25182
                                listeners: {
25183
                                    change: function (val) {
25184
                                        var _label = val.name;
25185
                                        var _form = val.formname;
25186
                                        var _Value = val.getValue();
25187
                                        var target = rec.TriggerCombo;
25188
                                        var custumFunc = rec.SelectFunction;
25189
                                        if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
25190
                                            Ext.Ajax.request({
25191
                                                async: false,
25192
                                                method: 'POST',
25193
                                                url: '/UserControl/GetStore',
25194
                                                params: {
25195
                                                    tableName: 'PCMFUNC',
25196
                                                    param: 'FuncName[equal]' + rec.custumFunc + ',Active[=]1'
25197
                                                },
25198
                                                success: function (response) {
25199
                                                    var results = Ext.decode(response.responseText);
25200
                                                    data_ = results.data[0];
25201
                                                    if (data_ != undefined) {
25202
                                                        custumFunc = data_.FunctionCode;
25203
                                                    }
25204
                                                }
25205
                                            });
25206
                                        }
25207
                                        var frm = Ext.ComponentQuery.query('form[name=' + _form + ']')[0];
25208
                                        if (frm) {
25209
                                            if (target) {
25210
                                                var f = frm.getForm().findField(target)
25211
                                                _store = f.getStore();
25212
                                                var _tbl = _store.proxy.extraParams.tableName;
25213
                                                var oldParam = _store.proxy.extraParams.param;
25214
                                                _store.proxy.extraParams = {
25215
                                                    tableName: _tbl,
25216
                                                    param: _label + '[=]' + _Value
25217
                                                };
25218
                                                _store.load();
25219
                                            }
25220
                                            if (custumFunc) {
25221
                                                eval(custumFunc)
25222
                                            }
25223
                                        }
25224
                                    }
25225
                                }
25226
                            });
25227
                            break;
25228
                        default:
25229
                            if (rec.DataType == 0) {
25230
                                if (rec.Length > 250) {
25231
                                    formfield = new Ext.form.TextArea({
25232
                                        allowBlank: allowblank,
25233
                                        fieldLabel: rec.ScreenCaption,
25234
                                        readOnly: readonly,
25235
                                        ////labelCls: 'label-minova',
25236
                                        labelWidth: me.labelWidth,
25237
                                        hidden: ishidden,
25238
                                        name: rec.FieldName,
25239
                                        msgTarget: 'side',
25240
                                        value: rec.DefaultValue,
25241
                                        maxLength: rec.Length,
25242
                                        anchor: '100%',
25243
                                        grow: true,
25244
                                        formname: formname_,
25245
                                        nameTable: nameTable_,
25246
                                        listeners: {
25247
                                            change: function (val) {
25248
                                                var _label = val.name;
25249
                                                var _form = val.formname;
25250
                                                var _Value = val.getValue();
25251
                                                var target = rec.TriggerCombo;
25252
                                                var custumFunc = rec.SelectFunction;
25253
                                                if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
25254
                                                    Ext.Ajax.request({
25255
                                                        async: false,
25256
                                                        method: 'POST',
25257
                                                        url: '/UserControl/GetStore',
25258
                                                        params: {
25259
                                                            tableName: 'PCMFUNC',
25260
                                                            param: 'FuncName[equal]' + rec.custumFunc + ',Active[=]1'
25261
                                                        },
25262
                                                        success: function (response) {
25263
                                                            var results = Ext.decode(response.responseText);
25264
                                                            data_ = results.data[0];
25265
                                                            if (data_ != undefined) {
25266
                                                                custumFunc = data_.FunctionCode;
25267
                                                            }
25268
                                                        }
25269
                                                    });
25270
                                                }
25271
                                                var frm = Ext.ComponentQuery.query('form[name=' + _form + ']')[0];
25272
                                                if (frm) {
25273
                                                    if (custumFunc) {
25274
                                                        eval(custumFunc)
25275
                                                    }
25276
                                                }
25277
                                            }
25278
                                        }
25279
                                    });
25280
                                } else {
25281
                                    if (rec.FixedValue != '') {
25282
                                        var storeData = [];
25283
                                        var str = rec.FixedValue;
25284
                                        var hasil = str.split('||');
25285
                                        hasil.forEach(function (h) {
25286
                                            store_ = h.split('=')
25287
                                            storeData.push({
25288
                                                code: store_[0],
25289
                                                desc: store_[1],
25290
                                            });
25291
                                        });
25292
                                        formfield = new Ext.form.ComboBox({
25293
                                            allowBlank: allowblank,
25294
                                            fieldLabel: rec.ScreenCaption,
25295
                                            forceSelection: true,
25296
                                            readOnly: readonly,
25297
                                            //labelCls: 'label-minova',
25298
                                            labelWidth: me.labelWidth,
25299
                                            hidden: ishidden,
25300
                                            name: rec.FieldName,
25301
                                            msgTarget: 'side',
25302
                                            value: rec.DefaultValue,
25303
                                            anchor: '100%',
25304
                                            formname: formname_,
25305
                                            nameTable: nameTable_,
25306
                                            formtarget: me.formname,
25307
                                            store: Ext.create('Ext.data.Store', {
25308
                                                storeId: 'store' + rec.FieldName,
25309
                                                autoLoad: true,
25310
                                                data: storeData
25311

    
25312
                                            }),
25313
                                            listeners: {
25314
                                                change: function (val) {
25315
                                                    var _label = val.name;
25316
                                                    var _form = val.formtarget;
25317
                                                    var _Value = val.getValue();
25318
                                                    var target = rec.TriggerCombo;
25319
                                                    var custumFunc = rec.SelectFunction;
25320
                                                    var frm = Ext.ComponentQuery.query('form[name=' + _form + ']')[0];
25321
                                                    if (frm) {
25322
                                                        if (target) {
25323
                                                            var f = frm.getForm().findField(target)
25324
                                                            _store = f.getStore();
25325
                                                            var _tbl = _store.proxy.extraParams.tableName;
25326
                                                            var oldParam = _store.proxy.extraParams.param;
25327
                                                            _store.proxy.extraParams = {
25328
                                                                tableName: _tbl,
25329
                                                                param: _label + '[=]' + _Value
25330
                                                            };
25331
                                                            _store.load();
25332
                                                        }
25333
                                                        if (custumFunc) {
25334
                                                            eval(custumFunc)
25335
                                                        }
25336
                                                    }
25337
                                                }
25338
                                            },
25339
                                            queryMode: 'local',
25340
                                            valueField: 'code',
25341
                                            displayField: 'desc',
25342
                                        });
25343
                                    } else {
25344
                                        formfield = new Ext.form.TextField({
25345
                                            allowBlank: allowblank,
25346
                                            fieldLabel: rec.ScreenCaption,
25347
                                            readOnly: readonly,
25348
                                            //labelCls: 'label-minova',
25349
                                            labelWidth: me.labelWidth,
25350
                                            hidden: ishidden,
25351
                                            name: rec.FieldName,
25352
                                            msgTarget: 'side',
25353
                                            value: rec.DefaultValue,
25354
                                            maxLength: rec.Length,
25355
                                            anchor: '100%',
25356
                                            formname: formname_,
25357
                                            nameTable: nameTable_,
25358
                                            listeners: {
25359
                                                change: function (val) {
25360
                                                    var _label = val.name;
25361
                                                    var _form = val.formname;
25362
                                                    var _Value = val.getValue();
25363
                                                    var target = rec.TriggerCombo;
25364
                                                    var custumFunc = rec.SelectFunction;
25365
                                                    if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
25366
                                                        Ext.Ajax.request({
25367
                                                            async: false,
25368
                                                            method: 'POST',
25369
                                                            url: '/UserControl/GetStore',
25370
                                                            params: {
25371
                                                                tableName: 'PCMFUNC',
25372
                                                                param: 'FuncName[equal]' + rec.custumFunc + ',Active[=]1'
25373
                                                            },
25374
                                                            success: function (response) {
25375
                                                                var results = Ext.decode(response.responseText);
25376
                                                                data_ = results.data[0];
25377
                                                                if (data_ != undefined) {
25378
                                                                    custumFunc = data_.FunctionCode;
25379
                                                                }
25380
                                                            }
25381
                                                        });
25382
                                                    }
25383
                                                    var frm = Ext.ComponentQuery.query('form[name=' + _form + ']')[0];
25384
                                                    if (frm) {
25385
                                                        if (custumFunc) {
25386
                                                            eval(custumFunc)
25387
                                                        }
25388
                                                    }
25389
                                                }
25390
                                            }
25391
                                        });
25392
                                    }
25393
                                }
25394
                            } else if (rec.DataType == 1 || rec.DataType == 2) {
25395
                                formfield = new MinovaUtil.MinovaES.MinovaNumberField({
25396
                                    allowBlank: allowblank,
25397
                                    fieldLabel: rec.ScreenCaption,
25398
                                    readOnly: readonly,
25399
                                    //labelCls: 'label-minova',
25400
                                    labelWidth: me.labelWidth,
25401
                                    msgTarget: 'side',
25402
                                    hidden: ishidden,
25403
                                    name: rec.FieldName,
25404
                                    value: rec.DefaultValue,
25405
                                    maxLength: rec.Length,
25406
                                    anchor: '100%',
25407
                                    formname: formname_,
25408
                                    nameTable: nameTable_,
25409
                                    fieldStyle: 'text-align:right;',
25410
                                    listeners: {
25411
                                        change: function (val) {
25412
                                            var _label = val.name;
25413
                                            var _form = val.formname;
25414
                                            var _Value = val.getValue();
25415
                                            var target = rec.TriggerCombo;
25416
                                            var custumFunc = rec.SelectFunction;
25417
                                            if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
25418
                                                Ext.Ajax.request({
25419
                                                    async: false,
25420
                                                    method: 'POST',
25421
                                                    url: '/UserControl/GetStore',
25422
                                                    params: {
25423
                                                        tableName: 'PCMFUNC',
25424
                                                        param: 'FuncName[equal]' + rec.custumFunc + ',Active[=]1'
25425
                                                    },
25426
                                                    success: function (response) {
25427
                                                        var results = Ext.decode(response.responseText);
25428
                                                        data_ = results.data[0];
25429
                                                        if (data_ != undefined) {
25430
                                                            custumFunc = data_.FunctionCode;
25431
                                                        }
25432
                                                    }
25433
                                                });
25434
                                            }
25435
                                            var frm = Ext.ComponentQuery.query('form[name=' + _form + ']')[0];
25436
                                            if (frm) {
25437
                                                if (target) {
25438
                                                    var f = frm.getForm().findField(target)
25439
                                                    _store = f.getStore();
25440
                                                    var _tbl = _store.proxy.extraParams.tableName;
25441
                                                    var oldParam = _store.proxy.extraParams.param;
25442
                                                    _store.proxy.extraParams = {
25443
                                                        tableName: _tbl,
25444
                                                        param: _label + '[=]' + _Value
25445
                                                    };
25446
                                                    _store.load();
25447
                                                }
25448
                                                if (custumFunc) {
25449
                                                    eval(custumFunc)
25450
                                                }
25451
                                            }
25452
                                        }
25453
                                    }
25454
                                });
25455
                            } else if (rec.DataType == 3) {
25456
                                formfield = new Ext.form.TextField({
25457
                                    allowBlank: allowblank,
25458
                                    fieldLabel: rec.ScreenCaption,
25459
                                    readOnly: readonly,
25460
                                    //labelCls: 'label-minova',
25461
                                    labelWidth: me.labelWidth,
25462
                                    msgTarget: 'side',
25463
                                    hidden: ishidden,
25464
                                    name: rec.FieldName,
25465
                                    value: rec.DefaultValue,
25466
                                    maxLength: rec.Length,
25467
                                    precision: rec.Prec,
25468
                                    anchor: '100%',
25469
                                    formname: formname_,
25470
                                    nameTable: nameTable_,
25471
                                    fieldStyle: 'text-align:right;',
25472
                                    maskRe: '^[0-9]+(\.[0-9]{1,2})?$',
25473
                                    listeners: {
25474
                                        change: function (val) {
25475
                                            var _label = val.name;
25476
                                            var _form = val.formname;
25477
                                            var _Value = val.getValue();
25478
                                            var target = rec.TriggerCombo;
25479
                                            var custumFunc = rec.SelectFunction;
25480
                                            if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
25481
                                                Ext.Ajax.request({
25482
                                                    async: false,
25483
                                                    method: 'POST',
25484
                                                    url: '/UserControl/GetStore',
25485
                                                    params: {
25486
                                                        tableName: 'PCMFUNC',
25487
                                                        param: 'FuncName[equal]' + rec.custumFunc + ',Active[=]1'
25488
                                                    },
25489
                                                    success: function (response) {
25490
                                                        var results = Ext.decode(response.responseText);
25491
                                                        data_ = results.data[0];
25492
                                                        if (data_ != undefined) {
25493
                                                            custumFunc = data_.FunctionCode;
25494
                                                        }
25495
                                                    }
25496
                                                });
25497
                                            }
25498
                                            var frm = Ext.ComponentQuery.query('form[name=' + _form + ']')[0];
25499
                                            if (frm) {
25500
                                                if (target) {
25501
                                                    var f = frm.getForm().findField(target)
25502
                                                    _store = f.getStore();
25503
                                                    var _tbl = _store.proxy.extraParams.tableName;
25504
                                                    var oldParam = _store.proxy.extraParams.param;
25505
                                                    _store.proxy.extraParams = {
25506
                                                        tableName: _tbl,
25507
                                                        param: _label + '[=]' + _Value
25508
                                                    };
25509
                                                    _store.load();
25510
                                                }
25511
                                                if (custumFunc) {
25512
                                                    eval(custumFunc)
25513
                                                }
25514
                                            }
25515
                                        }
25516
                                    }
25517
                                });
25518
                            }
25519
                    }
25520
                } else if (rec.SearchType != "") {
25521
                    if (rec.SearchType == "0") //combobox
25522
                    {
25523
                        valueField = null;
25524
                        displayValue = null;
25525
                        if (rec.TableRef != "") {
25526
                            Ext.Ajax.request({
25527
                                async: false,
25528
                                method: 'POST',
25529
                                url: '/UserControl/GetStore',
25530
                                params: {
25531
                                    tableName: 'SDATATABLEFIELD',
25532
                                    param: 'TableName[equal]' + rec.TableRef
25533
                                },
25534
                                success: function (response) {
25535
                                    var results = Ext.decode(response.responseText);
25536
                                    data_ = results.data;
25537
                                    if (data_ != undefined) {
25538
                                        valueField_ = $.grep(data_, function (r) {
25539
                                            return r.ValueField == '1'
25540
                                        });
25541
                                        if (valueField_.length > 0) {
25542
                                            valueField = valueField_[0].FieldName
25543
                                        }
25544
                                        displayValue_ = $.grep(data_, function (r) {
25545
                                            return r.DisplayValue == '1'
25546
                                        });
25547
                                        if (displayValue_.length > 0) {
25548
                                            displayValue = displayValue_[0].FieldName
25549
                                        }
25550
                                    }
25551
                                }
25552
                            });
25553
                        }
25554
                        formfield = new Ext.form.ComboBox({
25555
                            allowBlank: allowblank,
25556
                            fieldLabel: rec.ScreenCaption,
25557
                            forceSelection: true,
25558
                            anyMatch: true,
25559
                            readOnly: readonly,
25560
                            //labelCls: 'label-minova',
25561
                            labelWidth: me.labelWidth,
25562
                            hidden: ishidden,
25563
                            msgTarget: 'side',
25564
                            name: rec.FieldName,
25565
                            formname: formname_,
25566
                            nameTable: nameTable_,
25567
                            value: rec.DefaultValue,
25568
                            anchor: '100%', //width: '95%',
25569
                            //store: Ext.StoreMgr.lookup('store' + rec.FieldName) ? Ext.StoreMgr.lookup('store' + rec.FieldName):
25570
                            store: Ext.create('Ext.data.Store', {
25571
                                storeId: 'store' + rec.FieldName,
25572
                                autoLoad: false,
25573
                                proxy: {
25574
                                    method: 'POST',
25575
                                    type: 'ajax',
25576
                                    url: '/UserControl/GetStore',
25577
                                    extraParams: {
25578
                                        tableName: rec.TableRef,
25579
                                        param: rec.ParamCombo
25580
                                    },
25581
                                    reader: {
25582
                                        type: 'json',
25583
                                        root: 'data',
25584
                                        totalProperty: 'data[0].TotalCount'
25585
                                    }
25586
                                }
25587
                            }),
25588
                            formtarget: formname_,
25589
                            listeners: {
25590
                                afterrender: function (f) {
25591
                                    var store_ = f.getStore();
25592
                                    store_.load();
25593
                                },
25594
                                change: function (val) {
25595
                                    var _label = val.name;
25596
                                    var _form = val.formtarget;
25597
                                    var _Value = val.getValue();
25598
                                    var target = rec.TriggerCombo;
25599
                                    var custumFunc = rec.SelectFunction;
25600
                                    var frm = Ext.ComponentQuery.query('form[name=' + _form + ']')[0];
25601
                                    if (frm) {
25602

    
25603
                                        if (target) {
25604
                                            var f = frm.getForm().findField(target)
25605
                                            _store = f.getStore();
25606
                                            var _tbl = _store.proxy.extraParams.tableName;
25607
                                            var oldParam = _store.proxy.extraParams.param;
25608
                                            _store.proxy.extraParams = {
25609
                                                tableName: _tbl,
25610
                                                param: _label + '[=]' + _Value
25611
                                            };
25612
                                            _store.load();
25613
                                        }
25614
                                        if (custumFunc) {
25615
                                            eval(custumFunc)
25616
                                        }
25617
                                    }
25618
                                }
25619
                            },
25620
                            queryMode: 'local',
25621
                            displayField: displayValue,
25622
                            valueField: valueField,
25623
                        });
25624
                    } else if (rec.SearchType == '2') //Lookup
25625
                    {
25626
                        formfield = new MinovaUtil.MinovaES.MinovaLookupGrid({
25627
                            allowBlank: allowblank,
25628
                            fieldLabel: rec.ScreenCaption,
25629
                            readOnly: readonly,
25630
                            IsPrimaryKey: rec.IsPrimaryKey,
25631
                            msgTarget: 'side',
25632
                            //labelCls: 'label-minova',
25633
                            labelWidth: me.labelWidth,
25634
                            hidden: ishidden,
25635
                            name: rec.FieldName,
25636
                            tableName: rec.TableRef, //name tabel yang jadi ref-nya
25637
                            triggerCls: 'x-form-search-trigger',
25638
                            vtype: 'alphanum', // disable space
25639
                            formtarget: me.formname, // nama form  yang akan di set value-nya
25640
                            anchor: '100%',
25641
                            formname: formname_,
25642
                            nameTable: nameTable_,
25643
                            LookupFunction: rec.LookupFunction,
25644
                            SearchFunction: rec.SearchFunction,
25645
                            listeners: {
25646
                                change: function (val) {
25647
                                    var _label = val.name;
25648
                                    var _form = val.formname;
25649
                                    var _Value = val.getValue();
25650
                                    var target = rec.TriggerCombo;
25651
                                    var custumFunc = rec.SelectFunction;
25652
                                    if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
25653
                                        Ext.Ajax.request({
25654
                                            async: false,
25655
                                            method: 'POST',
25656
                                            url: '/UserControl/GetStore',
25657
                                            params: {
25658
                                                tableName: 'PCMFUNC',
25659
                                                param: 'FuncName[equal]' + rec.custumFunc + ',Active[=]1'
25660
                                            },
25661
                                            success: function (response) {
25662
                                                var results = Ext.decode(response.responseText);
25663
                                                data_ = results.data[0];
25664
                                                if (data_ != undefined) {
25665
                                                    custumFunc = data_.FunctionCode;
25666
                                                }
25667
                                            }
25668
                                        });
25669
                                    }
25670
                                    var frm = Ext.ComponentQuery.query('form[name=' + _form + ']')[0];
25671
                                    if (frm) {
25672

    
25673
                                        if (target) {
25674
                                            var f = frm.getForm().findField(target)
25675
                                            _store = f.getStore();
25676
                                            var _tbl = _store.proxy.extraParams.tableName;
25677
                                            var oldParam = _store.proxy.extraParams.param;
25678
                                            _store.proxy.extraParams = {
25679
                                                tableName: _tbl,
25680
                                                param: _label + '[=]' + _Value
25681
                                            };
25682
                                            _store.load();
25683
                                        }
25684

    
25685
                                        if (custumFunc) {
25686
                                            eval(custumFunc)
25687
                                        }
25688

    
25689
                                    }
25690

    
25691
                                },
25692

    
25693
                            },
25694
                        });
25695
                    } else if (rec.SearchType == '3') //lookup tree
25696
                    {
25697
                        formfield = new MinovaUtil.MinovaES.MinovaLookupTree({
25698
                            allowBlank: allowblank,
25699
                            fieldLabel: rec.ScreenCaption,
25700
                            readOnly: readonly,
25701
                            IsPrimaryKey: rec.IsPrimaryKey,
25702
                            //labelCls: 'label-minova',
25703
                            labelWidth: me.labelWidth,
25704
                            hidden: ishidden,
25705
                            name: rec.FieldName,
25706
                            msgTarget: 'side',
25707
                            triggerCls: 'x-form-search-trigger',
25708
                            treeSructure: rec.SearchFunction, //'O-O-P',
25709
                            objClassValue: rec.ParamCombo, //'O',
25710
                            formname: formname_,
25711
                            targetField: rec.FieldName,
25712
                            nameTable: nameTable_,
25713
                            editable: false,
25714
                            anchor: '100%',
25715
                            listeners: {
25716
                                change3: function (val) {
25717
                                    var _label = val.name;
25718
                                    var _form = val.formname;
25719
                                    var _Value = val.getValue();
25720
                                    var target = rec.TriggerCombo;
25721
                                    var custumFunc = rec.SelectFunction;
25722
                                    if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
25723
                                        Ext.Ajax.request({
25724
                                            async: false,
25725
                                            method: 'POST',
25726
                                            url: '/UserControl/GetStore',
25727
                                            params: {
25728
                                                tableName: 'PCMFUNC',
25729
                                                param: 'FuncName[equal]' + rec.custumFunc + ',Active[=]1'
25730
                                            },
25731
                                            success: function (response) {
25732
                                                var results = Ext.decode(response.responseText);
25733
                                                data_ = results.data[0];
25734
                                                if (data_ != undefined) {
25735
                                                    custumFunc = data_.FunctionCode;
25736
                                                }
25737
                                            }
25738
                                        });
25739
                                    }
25740
                                    var frm = Ext.ComponentQuery.query('form[name=' + _form + ']')[0];
25741
                                    if (frm) {
25742

    
25743
                                        if (target) {
25744
                                            var f = frm.getForm().findField(target)
25745
                                            _store = f.getStore();
25746
                                            var _tbl = _store.proxy.extraParams.tableName;
25747
                                            var oldParam = _store.proxy.extraParams.param;
25748
                                            _store.proxy.extraParams = {
25749
                                                tableName: _tbl,
25750
                                                param: _label + '[=]' + _Value
25751
                                            };
25752
                                            _store.load();
25753
                                        }
25754
                                        if (custumFunc) {
25755
                                            eval(custumFunc)
25756
                                        }
25757
                                    }
25758
                                },
25759
                                blur: function (val) {
25760
                                    //if(val.value.split('-').length != 2){
25761
                                    var _label = val.name;
25762
                                    var _form = val.formname;
25763
                                    var _Value = val.getValue();
25764
                                    var target = rec.TriggerCombo;
25765
                                    var custumFunc = rec.SelectFunction;
25766
                                    if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
25767
                                        Ext.Ajax.request({
25768
                                            async: false,
25769
                                            method: 'POST',
25770
                                            url: '/UserControl/GetStore',
25771
                                            params: {
25772
                                                tableName: 'PCMFUNC',
25773
                                                param: 'FuncName[equal]' + rec.custumFunc + ',Active[=]1'
25774
                                            },
25775
                                            success: function (response) {
25776
                                                var results = Ext.decode(response.responseText);
25777
                                                data_ = results.data[0];
25778
                                                if (data_ != undefined) {
25779
                                                    custumFunc = data_.FunctionCode;
25780
                                                }
25781
                                            }
25782
                                        });
25783
                                    }
25784
                                    var frm = Ext.ComponentQuery.query('form[name=' + _form + ']')[0];
25785
                                    if (frm) {
25786

    
25787
                                        if (target) {
25788
                                            var f = frm.getForm().findField(target)
25789
                                            _store = f.getStore();
25790
                                            var _tbl = _store.proxy.extraParams.tableName;
25791
                                            var oldParam = _store.proxy.extraParams.param;
25792
                                            _store.proxy.extraParams = {
25793
                                                tableName: _tbl,
25794
                                                param: _label + '[=]' + _Value
25795
                                            };
25796
                                            _store.load();
25797
                                        }
25798
                                        if (custumFunc) {
25799
                                            eval(custumFunc)
25800
                                        }
25801
                                    }
25802
                                    //}
25803
                                }
25804

    
25805
                            }
25806
                        });
25807
                    }
25808
                }
25809
                if (isDesk) {
25810
                    if (rec.ColumnNo == 1) {
25811
                        col1.push(formfield);
25812
                    } else {
25813
                        col2.push(formfield);
25814
                    }
25815
                } else {
25816
                    col1.push(formfield);
25817
                }
25818

    
25819
            });
25820
        }
25821
        Ext.applyIf(me, {
25822
            items:
25823
                [
25824
                    {
25825
                        //width: 450,
25826
                        //style: 'width: 50%',
25827
                        defaults: {
25828
                            layout: 'anchor',
25829
                            xtype: 'container',
25830
                            flex: 1,
25831
                            margin: '10px',
25832
                            //defaultType: 'textfield',
25833
                            //anchor: '100%',
25834
                            ////style: 'width: 50%',
25835
                        },
25836
                        items: col1,
25837
                        flex: 1,
25838
                    },
25839
                    {
25840
                        //width: 450,
25841
                        //style: 'width: 50%',
25842
                        defaults: {
25843
                            layout: 'anchor',
25844
                            xtype: 'container',
25845
                            flex: 1,
25846
                            margin: '10px',
25847
                            //defaultType: 'textfield',
25848
                            //anchor: '100%',
25849
                            ////style: 'width: 50%',
25850
                        },
25851
                        items: col2,
25852
                        flex: 1,
25853
                    }
25854
                ]
25855
        });
25856
        this.callParent();
25857
    },
25858
    listeners: {
25859
        boxready: function (dataview) {
25860
            //this.reset(); //YN 20211217 - Solusi Layout sebelah kanan terlalu geser
25861
        }
25862
    },
25863
    buttons: [{
25864
        text: 'Update',
25865
        handler: 'onSaveClick'
25866
    }, {
25867
        text: 'Cancel',
25868
        handler: 'onCancelClick'
25869
    }]
25870
});
25871

    
25872
/*Form ESS GeneratorT YN 20211216*/
25873
Ext.define('MinovaUtil.MinovaES.MinovaWorkflowFormGridT', {
25874
    extend: 'Ext.form.Panel',
25875
    alias: ['widget.MinovaWorkflowFormGridT', 'widget.minovaworkflowformgridT', 'widget.workflowformgridT'],
25876
    controller: 'workflowformgrid',
25877
    formname: this.name,
25878
    bizprocid: undefined,
25879
    bizflowid: undefined,
25880
    taskid: undefined,
25881
    tableName: undefined,
25882
    tableNameT: undefined,
25883
    parentKey: undefined,
25884
    titleform: undefined,
25885
    //resizable: true,
25886
    border: true,
25887
    autoScroll: true,
25888
    minHeight: 20,
25889
    layout: {
25890
        type: 'hbox'
25891
    },
25892
    listeners: {
25893
        render: function () {
25894
            if (this.titleform != undefined) {
25895
                this.setTitle(this.titleform);
25896
            }
25897
        },
25898
    },
25899
    buttonAlign: 'left',
25900
    defaults: {
25901
        layout: 'anchor',
25902
        xtype: 'container',
25903
        flex: 1,
25904
        margin: '10px',
25905
        //defaultType: 'textfield',
25906
        //anchor: '100%',
25907
        ////style: 'width: 50%',
25908
    },
25909
    initComponent: function () {
25910
        var col1 = [];
25911
        var col2 = [];
25912
        var me = this;
25913
        var LangID = localStorage.LangId;
25914
        var parameter = "LangID='" + LangID + "',BizProcessID='" + me.bizprocid + "',TaskID='" + me.taskid + "',TableName='" + me.tableName + "'";
25915
        var formname_ = me.name;
25916
        var nameTable_ = me.tableName;
25917
        var labelWidth = 150;
25918
        Ext.Ajax.request({
25919
            async: false,
25920
            method: 'POST',
25921
            url: '/UserControl/GetStore',
25922
            params: {
25923
                tableName: 'PDSWFSTRUCTUREFIELD',
25924
                param: parameter
25925
            },
25926
            success: function (response) {
25927
                var results = Ext.decode(response.responseText);
25928
                hasil = results.data;
25929
            }
25930
        });
25931
        if (hasil.length > 0) {
25932
            Ext.each(hasil, function (rec) {
25933
                var formfield = undefined;
25934
                var readonly = false;
25935
                var ishidden = false;
25936
                var allowblank = true;
25937
                var startDt = null;
25938
                var endDt = null;
25939
                if (rec.FieldName == 'StartDate' || rec.FieldName == 'EndDate') {
25940
                    startDt = 'StartDate';
25941
                    endDt = 'EndDate';
25942
                }
25943
                if (rec.IsReadOnly == '1') {
25944
                    readonly = true;
25945
                }
25946
                if (rec.IsRequired == '1') {
25947
                    allowblank = false;
25948
                }
25949
                if (rec.IsVisible == '0') {
25950
                    ishidden = true;
25951
                }
25952
                if (rec.SearchType == "") //textfield
25953
                {
25954
                    switch (rec.FormatRef) {
25955
                        case "date":
25956
                            if (rec.FieldName == 'StartDate' || rec.FieldName == 'EndDate') {
25957
                                formfield = new Ext.form.DateField({
25958
                                    allowBlank: allowblank,
25959
                                    fieldLabel: rec.ScreenCaption,
25960
                                    readOnly: readonly,
25961
                                    msgTarget: 'side',
25962
                                    //labelCls: 'label-minova',
25963
                                    labelWidth: labelWidth,
25964
                                    hidden: ishidden,
25965
                                    name: rec.FieldName,
25966
                                    submitFormat: 'Ymd',
25967
                                    value: rec.DefaultValue,
25968
                                    anchor: '100%',
25969
                                    vtype: 'daterange',
25970
                                    start: startDt,
25971
                                    end: endDt,
25972
                                    formname: formname_,
25973
                                    nameTable: nameTable_,
25974
                                    hideMode: 'visibility',
25975
                                    listeners: {
25976
                                        change: function (val) {
25977
                                            var _label = val.name;
25978
                                            var _form = val.formname;
25979
                                            var _Value = val.getValue();
25980
                                            var target = rec.TriggerCombo;
25981
                                            var custumFunc = rec.SelectFunction;
25982
                                            if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
25983
                                                Ext.Ajax.request({
25984
                                                    async: false,
25985
                                                    method: 'POST',
25986
                                                    url: '/UserControl/GetStore',
25987
                                                    params: {
25988
                                                        tableName: 'PCMFUNC',
25989
                                                        param: 'FuncName[equal]' + rec.custumFunc + ',Active[=]1'
25990
                                                    },
25991
                                                    success: function (response) {
25992
                                                        var results = Ext.decode(response.responseText);
25993
                                                        data_ = results.data[0];
25994
                                                        if (data_ != undefined) {
25995
                                                            custumFunc = data_.FunctionCode;
25996
                                                        }
25997
                                                    }
25998
                                                });
25999
                                            }
26000
                                            var frm = Ext.ComponentQuery.query('form[name=' + _form + ']')[0];
26001
                                            if (frm) {
26002
                                                if (custumFunc) {
26003
                                                    eval(custumFunc)
26004
                                                }
26005
                                            }
26006
                                        }
26007
                                    }
26008
                                });
26009
                            } else {
26010
                                formfield = new Ext.form.DateField({
26011
                                    allowBlank: allowblank,
26012
                                    fieldLabel: rec.ScreenCaption,
26013
                                    readOnly: readonly,
26014
                                    msgTarget: 'side',
26015
                                    //labelCls: 'label-minova',
26016
                                    labelWidth: labelWidth,
26017
                                    hidden: ishidden,
26018
                                    name: rec.FieldName,
26019
                                    submitFormat: 'Ymd',
26020
                                    value: rec.DefaultValue,
26021
                                    anchor: '100%',
26022
                                    formname: formname_,
26023
                                    nameTable: nameTable_,
26024
                                    hideMode: 'visibility',
26025
                                    listeners: {
26026
                                        change: function (val) {
26027
                                            var _label = val.name;
26028
                                            var _form = val.formname;
26029
                                            var _Value = val.getValue();
26030
                                            var target = rec.TriggerCombo;
26031
                                            var custumFunc = rec.SelectFunction;
26032
                                            if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
26033
                                                Ext.Ajax.request({
26034
                                                    async: false,
26035
                                                    method: 'POST',
26036
                                                    url: '/UserControl/GetStore',
26037
                                                    params: {
26038
                                                        tableName: 'PCMFUNC',
26039
                                                        param: 'FuncName[equal]' + rec.custumFunc + ',Active[=]1'
26040
                                                    },
26041
                                                    success: function (response) {
26042
                                                        var results = Ext.decode(response.responseText);
26043
                                                        data_ = results.data[0];
26044
                                                        if (data_ != undefined) {
26045
                                                            custumFunc = data_.FunctionCode;
26046
                                                        }
26047
                                                    }
26048
                                                });
26049
                                            }
26050
                                            var frm = Ext.ComponentQuery.query('form[name=' + _form + ']')[0];
26051
                                            if (frm) {
26052
                                                if (custumFunc) {
26053
                                                    eval(custumFunc)
26054
                                                }
26055
                                            }
26056
                                        }
26057
                                    }
26058
                                });
26059
                            }
26060
                            break;
26061
                        case "time":
26062
                            formfield = new Ext.form.TimeField({
26063
                                allowBlank: allowblank,
26064
                                fieldLabel: rec.ScreenCaption,
26065
                                readOnly: readonly,
26066
                                //labelCls: 'label-minova',
26067
                                labelWidth: labelWidth,
26068
                                hidden: ishidden,
26069
                                name: rec.FieldName,
26070
                                msgTarget: 'side',
26071
                                format: 'Hi',
26072
                                submitFormat: 'Hi',
26073
                                increment: 5,
26074
                                value: rec.DefaultValue,
26075
                                anchor: '100%',
26076
                                formname: formname_,
26077
                                nameTable: nameTable_,
26078
                                listeners: {
26079
                                    change: function (val) {
26080
                                        var _label = val.name;
26081
                                        var _form = val.formname;
26082
                                        var _Value = val.getValue();
26083
                                        var target = rec.TriggerCombo;
26084
                                        var custumFunc = rec.SelectFunction;
26085
                                        if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
26086
                                            Ext.Ajax.request({
26087
                                                async: false,
26088
                                                method: 'POST',
26089
                                                url: '/UserControl/GetStore',
26090
                                                params: {
26091
                                                    tableName: 'PCMFUNC',
26092
                                                    param: 'FuncName[equal]' + custumFunc + ',Active[=]1'
26093
                                                },
26094
                                                success: function (response) {
26095
                                                    var results = Ext.decode(response.responseText);
26096
                                                    data_ = results.data[0];
26097
                                                    if (data_ != undefined) {
26098
                                                        custumFunc = data_.FunctionCode;
26099
                                                    }
26100
                                                }
26101
                                            });
26102
                                        }
26103
                                        var frm = Ext.ComponentQuery.query('form[name=' + _form + ']')[0];
26104
                                        if (frm) {
26105
                                            if (custumFunc) {
26106
                                                eval(custumFunc)
26107
                                            }
26108
                                        }
26109
                                    }
26110
                                }
26111
                            });
26112
                            break;
26113
                        case "amount":
26114
                            formfield = new Ext.form.TextField({
26115
                                allowBlank: allowblank,
26116
                                fieldLabel: rec.ScreenCaption,
26117
                                readOnly: readonly,
26118
                                //labelCls: 'label-minova',
26119
                                labelWidth: labelWidth,
26120
                                hidden: ishidden,
26121
                                name: rec.FieldName,
26122
                                msgTarget: 'side',
26123
                                value: rec.DefaultValue,
26124
                                maxLength: rec.Length,
26125
                                anchor: '100%',
26126
                                formname: formname_,
26127
                                nameTable: nameTable_,
26128
                                fieldStyle: 'text-align:right;',
26129
                                listeners: {
26130
                                    change: function (val) {
26131
                                        var _label = val.name;
26132
                                        var _form = val.formname;
26133
                                        var _Value = val.getValue();
26134
                                        var target = rec.TriggerCombo;
26135
                                        var custumFunc = rec.SelectFunction;
26136
                                        if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
26137
                                            Ext.Ajax.request({
26138
                                                async: false,
26139
                                                method: 'POST',
26140
                                                url: '/UserControl/GetStore',
26141
                                                params: {
26142
                                                    tableName: 'PCMFUNC',
26143
                                                    param: 'FuncName[equal]' + rec.custumFunc + ',Active[=]1'
26144
                                                },
26145
                                                success: function (response) {
26146
                                                    var results = Ext.decode(response.responseText);
26147
                                                    data_ = results.data[0];
26148
                                                    if (data_ != undefined) {
26149
                                                        custumFunc = data_.FunctionCode;
26150
                                                    }
26151
                                                }
26152
                                            });
26153
                                        }
26154
                                        var frm = Ext.ComponentQuery.query('form[name=' + _form + ']')[0];
26155
                                        if (frm) {
26156
                                            if (custumFunc) {
26157
                                                eval(custumFunc)
26158
                                            }
26159
                                        }
26160
                                    }
26161
                                }
26162
                            });
26163
                            break;
26164
                        case "file":
26165
                            formfield = new MinovaUtil.MinovaES.UploadFile({
26166
                                allowBlank: allowblank,
26167
                                fieldLabel: rec.ScreenCaption,
26168
                                readOnly: readonly,
26169
                                readOnlyCls: 'minova-readonly',
26170
                                hidden: ishidden,
26171
                                //labelCls: 'label-minova',
26172
                                name: rec.FieldName,
26173
                                msgTarget: 'side',
26174
                                fieldname: rec.FieldName,
26175
                                IsPrimaryKey: rec.IsPrimaryKey,
26176
                                tableName: rec.TableRef,
26177
                                triggerCls: 'x-form-search-trigger',
26178
                                formtarget: me.formname,
26179
                                anchor: '100%',
26180
                                formname: formname_,
26181
                                nameTable: nameTable_,
26182
                                listeners: {
26183
                                    change: function (val) {
26184
                                        var _label = val.name;
26185
                                        var _form = val.formname;
26186
                                        var _Value = val.getValue();
26187
                                        var target = rec.TriggerCombo;
26188
                                        var custumFunc = rec.SelectFunction;
26189
                                        if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
26190
                                            Ext.Ajax.request({
26191
                                                async: false,
26192
                                                method: 'POST',
26193
                                                url: '/UserControl/GetStore',
26194
                                                params: {
26195
                                                    tableName: 'PCMFUNC',
26196
                                                    param: 'FuncName[equal]' + rec.custumFunc + ',Active[=]1'
26197
                                                },
26198
                                                success: function (response) {
26199
                                                    var results = Ext.decode(response.responseText);
26200
                                                    data_ = results.data[0];
26201
                                                    if (data_ != undefined) {
26202
                                                        custumFunc = data_.FunctionCode;
26203
                                                    }
26204
                                                }
26205
                                            });
26206
                                        }
26207
                                        var frm = Ext.ComponentQuery.query('form[name=' + _form + ']')[0];
26208
                                        if (frm) {
26209
                                            if (target) {
26210
                                                var f = frm.getForm().findField(target)
26211
                                                _store = f.getStore();
26212
                                                var _tbl = _store.proxy.extraParams.tableName;
26213
                                                var oldParam = _store.proxy.extraParams.param;
26214
                                                _store.proxy.extraParams = {
26215
                                                    tableName: _tbl,
26216
                                                    param: _label + '[=]' + _Value
26217
                                                };
26218
                                                _store.load();
26219
                                            }
26220
                                            if (custumFunc) {
26221
                                                eval(custumFunc)
26222
                                            }
26223
                                        }
26224
                                    }
26225
                                }
26226
                            });
26227
                            break;
26228
                        default:
26229
                            if (rec.DataType == 0) {
26230
                                if (rec.Length > 250) {
26231
                                    formfield = new Ext.form.TextArea({
26232
                                        allowBlank: allowblank,
26233
                                        fieldLabel: rec.ScreenCaption,
26234
                                        readOnly: readonly,
26235
                                        ////labelCls: 'label-minova',
26236
                                        labelWidth: labelWidth,
26237
                                        hidden: ishidden,
26238
                                        name: rec.FieldName,
26239
                                        msgTarget: 'side',
26240
                                        value: rec.DefaultValue,
26241
                                        maxLength: rec.Length,
26242
                                        anchor: '100%',
26243
                                        grow: true,
26244
                                        formname: formname_,
26245
                                        nameTable: nameTable_,
26246
                                        listeners: {
26247
                                            change: function (val) {
26248
                                                var _label = val.name;
26249
                                                var _form = val.formname;
26250
                                                var _Value = val.getValue();
26251
                                                var target = rec.TriggerCombo;
26252
                                                var custumFunc = rec.SelectFunction;
26253
                                                if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
26254
                                                    Ext.Ajax.request({
26255
                                                        async: false,
26256
                                                        method: 'POST',
26257
                                                        url: '/UserControl/GetStore',
26258
                                                        params: {
26259
                                                            tableName: 'PCMFUNC',
26260
                                                            param: 'FuncName[equal]' + rec.custumFunc + ',Active[=]1'
26261
                                                        },
26262
                                                        success: function (response) {
26263
                                                            var results = Ext.decode(response.responseText);
26264
                                                            data_ = results.data[0];
26265
                                                            if (data_ != undefined) {
26266
                                                                custumFunc = data_.FunctionCode;
26267
                                                            }
26268
                                                        }
26269
                                                    });
26270
                                                }
26271
                                                var frm = Ext.ComponentQuery.query('form[name=' + _form + ']')[0];
26272
                                                if (frm) {
26273
                                                    if (custumFunc) {
26274
                                                        eval(custumFunc)
26275
                                                    }
26276
                                                }
26277
                                            }
26278
                                        }
26279
                                    });
26280
                                } else {
26281
                                    if (rec.FixedValue != '') {
26282
                                        var storeData = [];
26283
                                        var str = rec.FixedValue;
26284
                                        var hasil = str.split('||');
26285
                                        hasil.forEach(function (h) {
26286
                                            store_ = h.split('=')
26287
                                            storeData.push({
26288
                                                code: store_[0],
26289
                                                desc: store_[1],
26290
                                            });
26291
                                        });
26292
                                        formfield = new Ext.form.ComboBox({
26293
                                            allowBlank: allowblank,
26294
                                            fieldLabel: rec.ScreenCaption,
26295
                                            forceSelection: true,
26296
                                            readOnly: readonly,
26297
                                            //labelCls: 'label-minova',
26298
                                            labelWidth: labelWidth,
26299
                                            hidden: ishidden,
26300
                                            name: rec.FieldName,
26301
                                            msgTarget: 'side',
26302
                                            value: rec.DefaultValue,
26303
                                            anchor: '100%',
26304
                                            formname: formname_,
26305
                                            nameTable: nameTable_,
26306
                                            formtarget: me.formname,
26307
                                            store: Ext.create('Ext.data.Store', {
26308
                                                storeId: 'store' + rec.FieldName,
26309
                                                autoLoad: true,
26310
                                                data: storeData
26311

    
26312
                                            }),
26313
                                            listeners: {
26314
                                                change: function (val) {
26315
                                                    var _label = val.name;
26316
                                                    var _form = val.formtarget;
26317
                                                    var _Value = val.getValue();
26318
                                                    var target = rec.TriggerCombo;
26319
                                                    var custumFunc = rec.SelectFunction;
26320
                                                    var frm = Ext.ComponentQuery.query('form[name=' + _form + ']')[0];
26321
                                                    if (frm) {
26322
                                                        if (target) {
26323
                                                            var f = frm.getForm().findField(target)
26324
                                                            _store = f.getStore();
26325
                                                            var _tbl = _store.proxy.extraParams.tableName;
26326
                                                            var oldParam = _store.proxy.extraParams.param;
26327
                                                            _store.proxy.extraParams = {
26328
                                                                tableName: _tbl,
26329
                                                                param: _label + '[=]' + _Value
26330
                                                            };
26331
                                                            _store.load();
26332
                                                        }
26333
                                                        if (custumFunc) {
26334
                                                            eval(custumFunc)
26335
                                                        }
26336
                                                    }
26337
                                                }
26338
                                            },
26339
                                            queryMode: 'local',
26340
                                            valueField: 'code',
26341
                                            displayField: 'desc',
26342
                                        });
26343
                                    } else {
26344
                                        formfield = new Ext.form.TextField({
26345
                                            allowBlank: allowblank,
26346
                                            fieldLabel: rec.ScreenCaption,
26347
                                            readOnly: readonly,
26348
                                            //labelCls: 'label-minova',
26349
                                            labelWidth: labelWidth,
26350
                                            hidden: ishidden,
26351
                                            name: rec.FieldName,
26352
                                            msgTarget: 'side',
26353
                                            value: rec.DefaultValue,
26354
                                            maxLength: rec.Length,
26355
                                            anchor: '100%',
26356
                                            formname: formname_,
26357
                                            nameTable: nameTable_,
26358
                                            listeners: {
26359
                                                change: function (val) {
26360
                                                    var _label = val.name;
26361
                                                    var _form = val.formname;
26362
                                                    var _Value = val.getValue();
26363
                                                    var target = rec.TriggerCombo;
26364
                                                    var custumFunc = rec.SelectFunction;
26365
                                                    if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
26366
                                                        Ext.Ajax.request({
26367
                                                            async: false,
26368
                                                            method: 'POST',
26369
                                                            url: '/UserControl/GetStore',
26370
                                                            params: {
26371
                                                                tableName: 'PCMFUNC',
26372
                                                                param: 'FuncName[equal]' + rec.custumFunc + ',Active[=]1'
26373
                                                            },
26374
                                                            success: function (response) {
26375
                                                                var results = Ext.decode(response.responseText);
26376
                                                                data_ = results.data[0];
26377
                                                                if (data_ != undefined) {
26378
                                                                    custumFunc = data_.FunctionCode;
26379
                                                                }
26380
                                                            }
26381
                                                        });
26382
                                                    }
26383
                                                    var frm = Ext.ComponentQuery.query('form[name=' + _form + ']')[0];
26384
                                                    if (frm) {
26385
                                                        if (custumFunc) {
26386
                                                            eval(custumFunc)
26387
                                                        }
26388
                                                    }
26389
                                                }
26390
                                            }
26391
                                        });
26392
                                    }
26393
                                }
26394
                            } else if (rec.DataType == 1 || rec.DataType == 2) {
26395
                                formfield = new MinovaUtil.MinovaES.MinovaNumberField({
26396
                                    allowBlank: allowblank,
26397
                                    fieldLabel: rec.ScreenCaption,
26398
                                    readOnly: readonly,
26399
                                    //labelCls: 'label-minova',
26400
                                    labelWidth: labelWidth,
26401
                                    msgTarget: 'side',
26402
                                    hidden: ishidden,
26403
                                    name: rec.FieldName,
26404
                                    value: rec.DefaultValue,
26405
                                    maxLength: rec.Length,
26406
                                    anchor: '100%',
26407
                                    formname: formname_,
26408
                                    nameTable: nameTable_,
26409
                                    fieldStyle: 'text-align:right;',
26410
                                    listeners: {
26411
                                        change: function (val) {
26412
                                            var _label = val.name;
26413
                                            var _form = val.formname;
26414
                                            var _Value = val.getValue();
26415
                                            var target = rec.TriggerCombo;
26416
                                            var custumFunc = rec.SelectFunction;
26417
                                            if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
26418
                                                Ext.Ajax.request({
26419
                                                    async: false,
26420
                                                    method: 'POST',
26421
                                                    url: '/UserControl/GetStore',
26422
                                                    params: {
26423
                                                        tableName: 'PCMFUNC',
26424
                                                        param: 'FuncName[equal]' + rec.custumFunc + ',Active[=]1'
26425
                                                    },
26426
                                                    success: function (response) {
26427
                                                        var results = Ext.decode(response.responseText);
26428
                                                        data_ = results.data[0];
26429
                                                        if (data_ != undefined) {
26430
                                                            custumFunc = data_.FunctionCode;
26431
                                                        }
26432
                                                    }
26433
                                                });
26434
                                            }
26435
                                            var frm = Ext.ComponentQuery.query('form[name=' + _form + ']')[0];
26436
                                            if (frm) {
26437
                                                if (target) {
26438
                                                    var f = frm.getForm().findField(target)
26439
                                                    _store = f.getStore();
26440
                                                    var _tbl = _store.proxy.extraParams.tableName;
26441
                                                    var oldParam = _store.proxy.extraParams.param;
26442
                                                    _store.proxy.extraParams = {
26443
                                                        tableName: _tbl,
26444
                                                        param: _label + '[=]' + _Value
26445
                                                    };
26446
                                                    _store.load();
26447
                                                }
26448
                                                if (custumFunc) {
26449
                                                    eval(custumFunc)
26450
                                                }
26451
                                            }
26452
                                        }
26453
                                    }
26454
                                });
26455
                            } else if (rec.DataType == 3) {
26456
                                formfield = new Ext.form.TextField({
26457
                                    allowBlank: allowblank,
26458
                                    fieldLabel: rec.ScreenCaption,
26459
                                    readOnly: readonly,
26460
                                    //labelCls: 'label-minova',
26461
                                    labelWidth: labelWidth,
26462
                                    msgTarget: 'side',
26463
                                    hidden: ishidden,
26464
                                    name: rec.FieldName,
26465
                                    value: rec.DefaultValue,
26466
                                    maxLength: rec.Length,
26467
                                    precision: rec.Prec,
26468
                                    anchor: '100%',
26469
                                    formname: formname_,
26470
                                    nameTable: nameTable_,
26471
                                    fieldStyle: 'text-align:right;',
26472
                                    maskRe: '^[0-9]+(\.[0-9]{1,2})?$',
26473
                                    listeners: {
26474
                                        change: function (val) {
26475
                                            var _label = val.name;
26476
                                            var _form = val.formname;
26477
                                            var _Value = val.getValue();
26478
                                            var target = rec.TriggerCombo;
26479
                                            var custumFunc = rec.SelectFunction;
26480
                                            if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
26481
                                                Ext.Ajax.request({
26482
                                                    async: false,
26483
                                                    method: 'POST',
26484
                                                    url: '/UserControl/GetStore',
26485
                                                    params: {
26486
                                                        tableName: 'PCMFUNC',
26487
                                                        param: 'FuncName[equal]' + rec.custumFunc + ',Active[=]1'
26488
                                                    },
26489
                                                    success: function (response) {
26490
                                                        var results = Ext.decode(response.responseText);
26491
                                                        data_ = results.data[0];
26492
                                                        if (data_ != undefined) {
26493
                                                            custumFunc = data_.FunctionCode;
26494
                                                        }
26495
                                                    }
26496
                                                });
26497
                                            }
26498
                                            var frm = Ext.ComponentQuery.query('form[name=' + _form + ']')[0];
26499
                                            if (frm) {
26500
                                                if (target) {
26501
                                                    var f = frm.getForm().findField(target)
26502
                                                    _store = f.getStore();
26503
                                                    var _tbl = _store.proxy.extraParams.tableName;
26504
                                                    var oldParam = _store.proxy.extraParams.param;
26505
                                                    _store.proxy.extraParams = {
26506
                                                        tableName: _tbl,
26507
                                                        param: _label + '[=]' + _Value
26508
                                                    };
26509
                                                    _store.load();
26510
                                                }
26511
                                                if (custumFunc) {
26512
                                                    eval(custumFunc)
26513
                                                }
26514
                                            }
26515
                                        }
26516
                                    }
26517
                                });
26518
                            }
26519
                    }
26520
                } else if (rec.SearchType != "") {
26521
                    if (rec.SearchType == "0") //combobox
26522
                    {
26523
                        valueField = null;
26524
                        displayValue = null;
26525
                        if (rec.TableRef != "") {
26526
                            Ext.Ajax.request({
26527
                                async: false,
26528
                                method: 'POST',
26529
                                url: '/UserControl/GetStore',
26530
                                params: {
26531
                                    tableName: 'SDATATABLEFIELD',
26532
                                    param: 'TableName[equal]' + rec.TableRef
26533
                                },
26534
                                success: function (response) {
26535
                                    var results = Ext.decode(response.responseText);
26536
                                    data_ = results.data;
26537
                                    if (data_ != undefined) {
26538
                                        valueField_ = $.grep(data_, function (r) {
26539
                                            return r.ValueField == '1'
26540
                                        });
26541
                                        if (valueField_.length > 0) {
26542
                                            valueField = valueField_[0].FieldName
26543
                                        }
26544
                                        displayValue_ = $.grep(data_, function (r) {
26545
                                            return r.DisplayValue == '1'
26546
                                        });
26547
                                        if (displayValue_.length > 0) {
26548
                                            displayValue = displayValue_[0].FieldName
26549
                                        }
26550
                                    }
26551
                                }
26552
                            });
26553
                        }
26554
                        formfield = new Ext.form.ComboBox({
26555
                            allowBlank: allowblank,
26556
                            fieldLabel: rec.ScreenCaption,
26557
                            forceSelection: true,
26558
                            anyMatch: true,
26559
                            readOnly: readonly,
26560
                            //labelCls: 'label-minova',
26561
                            labelWidth: labelWidth,
26562
                            hidden: ishidden,
26563
                            msgTarget: 'side',
26564
                            name: rec.FieldName,
26565
                            formname: formname_,
26566
                            nameTable: nameTable_,
26567
                            value: rec.DefaultValue,
26568
                            anchor: '100%', //width: '95%',
26569
                            store: Ext.create('Ext.data.Store', {
26570
                                storeId: 'store' + rec.FieldName,
26571
                                autoLoad: false,
26572
                                proxy: {
26573
                                    method: 'POST',
26574
                                    type: 'ajax',
26575
                                    url: '/UserControl/GetStore',
26576
                                    extraParams: {
26577
                                        tableName: rec.TableRef,
26578
                                        param: rec.ParamCombo
26579
                                    },
26580
                                    reader: {
26581
                                        type: 'json',
26582
                                        root: 'data',
26583
                                        totalProperty: 'data[0].TotalCount'
26584
                                    }
26585
                                }
26586
                            }),
26587
                            formtarget: formname_,
26588
                            listeners: {
26589
                                afterrender: function (f) {
26590
                                    var store_ = f.getStore();
26591
                                    store_.load();
26592
                                },
26593
                                change: function (val) {
26594
                                    var _label = val.name;
26595
                                    var _form = val.formtarget;
26596
                                    var _Value = val.getValue();
26597
                                    var target = rec.TriggerCombo;
26598
                                    var custumFunc = rec.SelectFunction;
26599
                                    var frm = Ext.ComponentQuery.query('form[name=' + _form + ']')[0];
26600
                                    if (frm) {
26601

    
26602
                                        if (target) {
26603
                                            var f = frm.getForm().findField(target)
26604
                                            _store = f.getStore();
26605
                                            var _tbl = _store.proxy.extraParams.tableName;
26606
                                            var oldParam = _store.proxy.extraParams.param;
26607
                                            _store.proxy.extraParams = {
26608
                                                tableName: _tbl,
26609
                                                param: _label + '[=]' + _Value
26610
                                            };
26611
                                            _store.load();
26612
                                        }
26613
                                        if (custumFunc) {
26614
                                            eval(custumFunc)
26615
                                        }
26616
                                    }
26617
                                }
26618
                            },
26619
                            queryMode: 'local',
26620
                            displayField: displayValue,
26621
                            valueField: valueField,
26622
                        });
26623
                    } else if (rec.SearchType == '2') //Lookup
26624
                    {
26625
                        formfield = new MinovaUtil.MinovaES.MinovaLookupGrid({
26626
                            allowBlank: allowblank,
26627
                            fieldLabel: rec.ScreenCaption,
26628
                            readOnly: readonly,
26629
                            IsPrimaryKey: rec.IsPrimaryKey,
26630
                            msgTarget: 'side',
26631
                            //labelCls: 'label-minova',
26632
                            labelWidth: labelWidth,
26633
                            hidden: ishidden,
26634
                            name: rec.FieldName,
26635
                            tableName: rec.TableRef, //name tabel yang jadi ref-nya
26636
                            triggerCls: 'x-form-search-trigger',
26637
                            vtype: 'alphanum', // disable space
26638
                            formtarget: me.formname, // nama form  yang akan di set value-nya
26639
                            anchor: '100%',
26640
                            formname: formname_,
26641
                            nameTable: nameTable_,
26642
                            LookupFunction: rec.LookupFunction,
26643
                            SearchFunction: rec.SearchFunction,
26644
                            listeners: {
26645
                                change: function (val) {
26646
                                    var _label = val.name;
26647
                                    var _form = val.formname;
26648
                                    var _Value = val.getValue();
26649
                                    var target = rec.TriggerCombo;
26650
                                    var custumFunc = rec.SelectFunction;
26651
                                    if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
26652
                                        Ext.Ajax.request({
26653
                                            async: false,
26654
                                            method: 'POST',
26655
                                            url: '/UserControl/GetStore',
26656
                                            params: {
26657
                                                tableName: 'PCMFUNC',
26658
                                                param: 'FuncName[equal]' + rec.custumFunc + ',Active[=]1'
26659
                                            },
26660
                                            success: function (response) {
26661
                                                var results = Ext.decode(response.responseText);
26662
                                                data_ = results.data[0];
26663
                                                if (data_ != undefined) {
26664
                                                    custumFunc = data_.FunctionCode;
26665
                                                }
26666
                                            }
26667
                                        });
26668
                                    }
26669
                                    var frm = Ext.ComponentQuery.query('form[name=' + _form + ']')[0];
26670
                                    if (frm) {
26671

    
26672
                                        if (target) {
26673
                                            var f = frm.getForm().findField(target)
26674
                                            _store = f.getStore();
26675
                                            var _tbl = _store.proxy.extraParams.tableName;
26676
                                            var oldParam = _store.proxy.extraParams.param;
26677
                                            _store.proxy.extraParams = {
26678
                                                tableName: _tbl,
26679
                                                param: _label + '[=]' + _Value
26680
                                            };
26681
                                            _store.load();
26682
                                        }
26683

    
26684
                                        if (custumFunc) {
26685
                                            eval(custumFunc)
26686
                                        }
26687

    
26688
                                    }
26689

    
26690
                                },
26691

    
26692
                            },
26693
                        });
26694
                    } else if (rec.SearchType == '3') //lookup tree
26695
                    {
26696
                        formfield = new MinovaUtil.MinovaES.MinovaLookupTree({
26697
                            allowBlank: allowblank,
26698
                            fieldLabel: rec.ScreenCaption,
26699
                            readOnly: readonly,
26700
                            IsPrimaryKey: rec.IsPrimaryKey,
26701
                            //labelCls: 'label-minova',
26702
                            labelWidth: labelWidth,
26703
                            hidden: ishidden,
26704
                            name: rec.FieldName,
26705
                            msgTarget: 'side',
26706
                            triggerCls: 'x-form-search-trigger',
26707
                            treeSructure: rec.SearchFunction, //'O-O-P',
26708
                            objClassValue: rec.ParamCombo, //'O',
26709
                            formname: formname_,
26710
                            targetField: rec.FieldName,
26711
                            nameTable: nameTable_,
26712
                            editable: false,
26713
                            anchor: '100%',
26714
                            listeners: {
26715
                                change3: function (val) {
26716
                                    var _label = val.name;
26717
                                    var _form = val.formname;
26718
                                    var _Value = val.getValue();
26719
                                    var target = rec.TriggerCombo;
26720
                                    var custumFunc = rec.SelectFunction;
26721
                                    if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
26722
                                        Ext.Ajax.request({
26723
                                            async: false,
26724
                                            method: 'POST',
26725
                                            url: '/UserControl/GetStore',
26726
                                            params: {
26727
                                                tableName: 'PCMFUNC',
26728
                                                param: 'FuncName[equal]' + rec.custumFunc + ',Active[=]1'
26729
                                            },
26730
                                            success: function (response) {
26731
                                                var results = Ext.decode(response.responseText);
26732
                                                data_ = results.data[0];
26733
                                                if (data_ != undefined) {
26734
                                                    custumFunc = data_.FunctionCode;
26735
                                                }
26736
                                            }
26737
                                        });
26738
                                    }
26739
                                    var frm = Ext.ComponentQuery.query('form[name=' + _form + ']')[0];
26740
                                    if (frm) {
26741

    
26742
                                        if (target) {
26743
                                            var f = frm.getForm().findField(target)
26744
                                            _store = f.getStore();
26745
                                            var _tbl = _store.proxy.extraParams.tableName;
26746
                                            var oldParam = _store.proxy.extraParams.param;
26747
                                            _store.proxy.extraParams = {
26748
                                                tableName: _tbl,
26749
                                                param: _label + '[=]' + _Value
26750
                                            };
26751
                                            _store.load();
26752
                                        }
26753
                                        if (custumFunc) {
26754
                                            eval(custumFunc)
26755
                                        }
26756
                                    }
26757
                                },
26758
                                blur: function (val) {
26759
                                    //if(val.value.split('-').length != 2){
26760
                                    var _label = val.name;
26761
                                    var _form = val.formname;
26762
                                    var _Value = val.getValue();
26763
                                    var target = rec.TriggerCombo;
26764
                                    var custumFunc = rec.SelectFunction;
26765
                                    if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
26766
                                        Ext.Ajax.request({
26767
                                            async: false,
26768
                                            method: 'POST',
26769
                                            url: '/UserControl/GetStore',
26770
                                            params: {
26771
                                                tableName: 'PCMFUNC',
26772
                                                param: 'FuncName[equal]' + rec.custumFunc + ',Active[=]1'
26773
                                            },
26774
                                            success: function (response) {
26775
                                                var results = Ext.decode(response.responseText);
26776
                                                data_ = results.data[0];
26777
                                                if (data_ != undefined) {
26778
                                                    custumFunc = data_.FunctionCode;
26779
                                                }
26780
                                            }
26781
                                        });
26782
                                    }
26783
                                    var frm = Ext.ComponentQuery.query('form[name=' + _form + ']')[0];
26784
                                    if (frm) {
26785

    
26786
                                        if (target) {
26787
                                            var f = frm.getForm().findField(target)
26788
                                            _store = f.getStore();
26789
                                            var _tbl = _store.proxy.extraParams.tableName;
26790
                                            var oldParam = _store.proxy.extraParams.param;
26791
                                            _store.proxy.extraParams = {
26792
                                                tableName: _tbl,
26793
                                                param: _label + '[=]' + _Value
26794
                                            };
26795
                                            _store.load();
26796
                                        }
26797
                                        if (custumFunc) {
26798
                                            eval(custumFunc)
26799
                                        }
26800
                                    }
26801
                                    //}
26802
                                }
26803

    
26804
                            }
26805
                        });
26806
                    }
26807
                }
26808
                if (isDesk) {
26809
                    if (rec.ColumnNo == 1) {
26810
                        col1.push(formfield);
26811
                    } else {
26812
                        col2.push(formfield);
26813
                    }
26814
                } else {
26815
                    col1.push(formfield);
26816
                }
26817

    
26818
            });
26819
        }
26820
        Ext.applyIf(me, {
26821
            items:
26822
                [
26823
                    {
26824
                        //width: 450,
26825
                        //style: 'width: 50%',
26826
                        defaults: {
26827
                            layout: 'anchor',
26828
                            xtype: 'container',
26829
                            flex: 1,
26830
                            margin: '10px',
26831
                            //defaultType: 'textfield',
26832
                            //anchor: '100%',
26833
                            ////style: 'width: 50%',
26834
                        },
26835
                        items: col1,
26836
                        flex: 1,
26837
                    },
26838
                    {
26839
                        //width: 450,
26840
                        //style: 'width: 50%',
26841
                        defaults: {
26842
                            layout: 'anchor',
26843
                            xtype: 'container',
26844
                            flex: 1,
26845
                            margin: '10px',
26846
                            //defaultType: 'textfield',
26847
                            //anchor: '100%',
26848
                            ////style: 'width: 50%',
26849
                        },
26850
                        items: col2,
26851
                        flex: 1,
26852
                    }
26853
                ]
26854
        });
26855
        this.callParent();
26856
    },
26857
    listeners: {
26858
        boxready: function (dataview) {
26859
            //this.reset(); //YN 20211217 - Solusi Layout sebelah kanan terlalu geser
26860
        }
26861
    },
26862
    buttons: [{
26863
        text: 'Update',
26864
        handler: 'onSaveClick'
26865
    }, {
26866
        text: 'Cancel',
26867
        handler: 'onCancelClick'
26868
    }]
26869
});
26870

    
26871
Ext.define('MinovaUtil.MinovaES.MinovaWorkflowFormGridController', {
26872
    extend: 'Ext.app.ViewController',
26873
    alias: 'controller.workflowformgrid',
26874
    //afterrender: function () {
26875
    //    this.reset();
26876
    //},
26877

    
26878
    onSaveClick: function (btn, e, eOpts) {
26879
        // Save the changes pending in the dialog's child session back to the
26880
        // parent session.
26881
        //this.dialog.getSession().save();
26882
        var frmPanel = this.getView();
26883
        //var panel = this.up('form');
26884
        //var form = panel.getForm();
26885
        if (frmPanel.isValid()) {
26886
            //Ext.Msg.alert('Success');
26887
            var grdPanel = Ext.ComponentQuery.query('[name=grid' + frmPanel.tableName + ']')[0];
26888
            var dtrec = grdPanel.getView().getSelectionModel().getSelection()[0];
26889
            values = frmPanel.getValues();
26890
            try {               
26891
                dtrec.set(values);
26892
				btn.fireEvent("click2"); //YN 20220315
26893
                }
26894
            catch (er) {
26895
                //grdPanel.reconfigure();
26896
				//e.cancelBubble = true;
26897
                console.log(er);
26898
            }
26899
            frmPanel.hide();
26900
            //this.onCancelClick();
26901
        } else {
26902
            fieldNames = [];
26903
            fields = this.getInvalidFields(frmPanel);
26904
            for (var i = 0; i < fields.length; i++) {
26905
                field = fields[i];
26906
                fieldNames.push(i + 1 + '. ' + field.fieldLabel + ' (' + field.activeErrors[0] + ')');
26907
            }
26908
            //console.debug(fieldNames);
26909
            Ext.MessageBox.alert('Invalid Fields', 'The following fields are invalid: </br> ' + fieldNames.join(' </br>'));
26910
			//e.cancelBubble = true;
26911
        }
26912
    },
26913

    
26914
    onCancelClick: function () {
26915
        //this.getView().remove(this.dialog);
26916
        //this.dialog = null;
26917
        var frmPanel = this.getView();
26918
        frmPanel.reset();
26919
        frmPanel.hide();
26920
    },
26921

    
26922
    getInvalidFields: function (frmPanel) {
26923
        var invalidFields = [];
26924
        Ext.suspendLayouts();
26925
        frmPanel.getForm().getFields().filterBy(function (field) {
26926
            if (field.validate()) return;
26927
            invalidFields.push(field);
26928
        });
26929
        Ext.resumeLayouts(true);
26930
        return invalidFields;
26931
    },
26932
});
26933

    
26934
/*Form ESS Generator Layout: Auto if just 1 column YN 20211216*/
26935
Ext.define('MinovaUtil.MinovaES.MinovaWorkflowForm1', {
26936
    extend: 'Ext.form.Panel',
26937
    alias: ['widget.MinovaWorkflowForm1', 'widget.minovaworkflowform1', 'widget.workflowform1'],
26938
    formname: this.name,
26939
    bizprocid: undefined,
26940
    bizflowid: undefined,
26941
    taskid: undefined,
26942
    tableName: undefined,
26943
    tableNameT: undefined,
26944
    parentKey: undefined,
26945
    titleform: undefined,
26946
    name: undefined,
26947
    labelAlign: 'left',
26948
    labelWidth: 150,
26949
    labelSeparator: undefined,
26950
    //resizable: true,
26951
    border: true,
26952
    autoScroll: true,
26953
    minHeight: 20,
26954
    marginDefault: 10,
26955
    layout: {
26956
        type: (isDesk == true) ? 'hbox': 'auto'
26957
    },
26958
    listeners: {
26959
        render: function () {
26960
            if (this.titleform != undefined) {
26961
                this.setTitle(this.titleform);
26962
            }
26963
        },
26964
    },
26965
    defaults: {
26966
        layout: 'anchor',
26967
        xtype: 'container',
26968
        flex: 1,
26969
        margin: this.marginDefault,
26970
        //defaultType: 'textfield',
26971
        //anchor: '100%',
26972
        ////style: 'width: 50%',
26973
    },
26974
    initComponent: function () {
26975
        var col1 = [];
26976
        var col2 = [];
26977
        var col0 = [];
26978
        var me = this;
26979
        var LangID = localStorage.LangId;
26980
        var parameter = "LangID='" + LangID + "',BizProcessID='" + me.bizprocid + "',TaskID='" + me.taskid + "',TableName='" + me.tableName + "'";
26981
        var formname_ = me.name;
26982
        var nameTable_ = me.tableName;
26983
        var labelWidth = me.labelWidth;
26984
        Ext.Ajax.request({
26985
            async: false,
26986
            method: 'POST',
26987
            url: '/UserControl/GetStore',
26988
            params: {
26989
                tableName: 'PDSWFSTRUCTUREFIELD',
26990
                param: parameter
26991
            },
26992
            success: function (response) {
26993
                var results = Ext.decode(response.responseText);
26994
                hasil = results.data;
26995
            }
26996
        });
26997
        if (hasil.length > 0) {
26998
            Ext.each(hasil, function (rec) {
26999
                var formfield = undefined;
27000
                var readonly = false;
27001
                var ishidden = false;
27002
                var allowblank = true;
27003
                var startDt = null;
27004
                var endDt = null;
27005
                if (rec.FieldName == 'StartDate' || rec.FieldName == 'EndDate') {
27006
                    startDt = 'StartDate';
27007
                    endDt = 'EndDate';
27008
                }
27009
                if (rec.IsReadOnly == '1') {
27010
                    readonly = true;
27011
                }
27012
                if (rec.IsRequired == '1') {
27013
                    allowblank = false;
27014
                }
27015
                if (rec.IsVisible == '0') {
27016
                    ishidden = true;
27017
                }
27018
                if (rec.SearchType == "") //textfield
27019
                {
27020
                    switch (rec.FormatRef) {
27021
                        case "date":
27022
                            if (rec.FieldName == 'StartDate' || rec.FieldName == 'EndDate') {
27023
                                formfield = new Ext.form.DateField({
27024
                                    allowBlank: allowblank,
27025
                                    fieldLabel: rec.ScreenCaption,
27026
                                    readOnly: readonly,
27027
                                    msgTarget: 'side',
27028
                                    //labelCls: 'label-minova',
27029
                                    labelWidth: labelWidth,
27030
                                    hidden: ishidden,
27031
                                    name: rec.FieldName,
27032
                                    submitFormat: 'Ymd',
27033
                                    value: rec.DefaultValue,
27034
                                    anchor: '100%',
27035
                                    vtype: 'daterange',
27036
                                    start: startDt,
27037
                                    end: endDt,
27038
                                    formname: formname_,
27039
                                    nameTable: nameTable_,
27040
                                    hideMode: 'visibility',
27041
                                    listeners: {
27042
                                        change: function (val) {
27043
                                            var _label = val.name;
27044
                                            var _form = val.formname;
27045
                                            var _Value = val.getValue();
27046
                                            var target = rec.TriggerCombo;
27047
                                            var custumFunc = rec.SelectFunction;
27048
                                            if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
27049
                                                Ext.Ajax.request({
27050
                                                    async: false,
27051
                                                    method: 'POST',
27052
                                                    url: '/UserControl/GetStore',
27053
                                                    params: {
27054
                                                        tableName: 'PCMFUNC',
27055
                                                        param: 'FuncName[equal]' + rec.custumFunc + ',Active[=]1'
27056
                                                    },
27057
                                                    success: function (response) {
27058
                                                        var results = Ext.decode(response.responseText);
27059
                                                        data_ = results.data[0];
27060
                                                        if (data_ != undefined) {
27061
                                                            custumFunc = data_.FunctionCode;
27062
                                                        }
27063
                                                    }
27064
                                                });
27065
                                            }
27066
                                            var frm = Ext.ComponentQuery.query('form[name=' + _form + ']')[0];
27067
                                            if (frm) {
27068
                                                if (custumFunc) {
27069
                                                    eval(custumFunc)
27070
                                                }
27071
                                            }
27072
                                        }
27073
                                    }
27074
                                });
27075
                            } else {
27076
                                formfield = new Ext.form.DateField({
27077
                                    allowBlank: allowblank,
27078
                                    fieldLabel: rec.ScreenCaption,
27079
                                    readOnly: readonly,
27080
                                    msgTarget: 'side',
27081
                                    //labelCls: 'label-minova',
27082
                                    labelWidth: labelWidth,
27083
                                    hidden: ishidden,
27084
                                    name: rec.FieldName,
27085
                                    submitFormat: 'Ymd',
27086
                                    value: rec.DefaultValue,
27087
                                    anchor: '100%',
27088
                                    formname: formname_,
27089
                                    nameTable: nameTable_,
27090
                                    hideMode: 'visibility',
27091
                                    listeners: {
27092
                                        change: function (val) {
27093
                                            var _label = val.name;
27094
                                            var _form = val.formname;
27095
                                            var _Value = val.getValue();
27096
                                            var target = rec.TriggerCombo;
27097
                                            var custumFunc = rec.SelectFunction;
27098
                                            if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
27099
                                                Ext.Ajax.request({
27100
                                                    async: false,
27101
                                                    method: 'POST',
27102
                                                    url: '/UserControl/GetStore',
27103
                                                    params: {
27104
                                                        tableName: 'PCMFUNC',
27105
                                                        param: 'FuncName[equal]' + rec.custumFunc + ',Active[=]1'
27106
                                                    },
27107
                                                    success: function (response) {
27108
                                                        var results = Ext.decode(response.responseText);
27109
                                                        data_ = results.data[0];
27110
                                                        if (data_ != undefined) {
27111
                                                            custumFunc = data_.FunctionCode;
27112
                                                        }
27113
                                                    }
27114
                                                });
27115
                                            }
27116
                                            var frm = Ext.ComponentQuery.query('form[name=' + _form + ']')[0];
27117
                                            if (frm) {
27118
                                                if (custumFunc) {
27119
                                                    eval(custumFunc)
27120
                                                }
27121
                                            }
27122
                                        }
27123
                                    }
27124
                                });
27125
                            }
27126
                            break;
27127
                        case "time":
27128
                            formfield = new Ext.form.TimeField({
27129
                                allowBlank: allowblank,
27130
                                fieldLabel: rec.ScreenCaption,
27131
                                readOnly: readonly,
27132
                                //labelCls: 'label-minova',
27133
                                labelWidth: labelWidth,
27134
                                hidden: ishidden,
27135
                                name: rec.FieldName,
27136
                                msgTarget: 'side',
27137
                                format: 'Hi',
27138
                                submitFormat: 'Hi',
27139
                                increment: 5,
27140
                                value: rec.DefaultValue,
27141
                                anchor: '100%',
27142
                                formname: formname_,
27143
                                nameTable: nameTable_,
27144
                                listeners: {
27145
                                    change: function (val) {
27146
                                        var _label = val.name;
27147
                                        var _form = val.formname;
27148
                                        var _Value = val.getValue();
27149
                                        var target = rec.TriggerCombo;
27150
                                        var custumFunc = rec.SelectFunction;
27151
                                        if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
27152
                                            Ext.Ajax.request({
27153
                                                async: false,
27154
                                                method: 'POST',
27155
                                                url: '/UserControl/GetStore',
27156
                                                params: {
27157
                                                    tableName: 'PCMFUNC',
27158
                                                    param: 'FuncName[equal]' + custumFunc + ',Active[=]1'
27159
                                                },
27160
                                                success: function (response) {
27161
                                                    var results = Ext.decode(response.responseText);
27162
                                                    data_ = results.data[0];
27163
                                                    if (data_ != undefined) {
27164
                                                        custumFunc = data_.FunctionCode;
27165
                                                    }
27166
                                                }
27167
                                            });
27168
                                        }
27169
                                        var frm = Ext.ComponentQuery.query('form[name=' + _form + ']')[0];
27170
                                        if (frm) {
27171
                                            if (custumFunc) {
27172
                                                eval(custumFunc)
27173
                                            }
27174
                                        }
27175
                                    }
27176
                                }
27177
                            });
27178
                            break;
27179
                        case "amount":
27180
                            formfield = new Ext.form.TextField({
27181
                                allowBlank: allowblank,
27182
                                fieldLabel: rec.ScreenCaption,
27183
                                readOnly: readonly,
27184
                                //labelCls: 'label-minova',
27185
                                labelWidth: labelWidth,
27186
                                hidden: ishidden,
27187
                                name: rec.FieldName,
27188
                                msgTarget: 'side',
27189
                                value: rec.DefaultValue,
27190
                                maxLength: rec.Length,
27191
                                anchor: '100%',
27192
                                formname: formname_,
27193
                                nameTable: nameTable_,
27194
                                fieldStyle: 'text-align:right;',
27195
                                listeners: {
27196
                                    change: function (val) {
27197
                                        var _label = val.name;
27198
                                        var _form = val.formname;
27199
                                        var _Value = val.getValue();
27200
                                        var target = rec.TriggerCombo;
27201
                                        var custumFunc = rec.SelectFunction;
27202
                                        if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
27203
                                            Ext.Ajax.request({
27204
                                                async: false,
27205
                                                method: 'POST',
27206
                                                url: '/UserControl/GetStore',
27207
                                                params: {
27208
                                                    tableName: 'PCMFUNC',
27209
                                                    param: 'FuncName[equal]' + rec.custumFunc + ',Active[=]1'
27210
                                                },
27211
                                                success: function (response) {
27212
                                                    var results = Ext.decode(response.responseText);
27213
                                                    data_ = results.data[0];
27214
                                                    if (data_ != undefined) {
27215
                                                        custumFunc = data_.FunctionCode;
27216
                                                    }
27217
                                                }
27218
                                            });
27219
                                        }
27220
                                        var frm = Ext.ComponentQuery.query('form[name=' + _form + ']')[0];
27221
                                        if (frm) {
27222
                                            if (custumFunc) {
27223
                                                eval(custumFunc)
27224
                                            }
27225
                                        }
27226
                                    }
27227
                                }
27228
                            });
27229
                            break;
27230
                        case "file":
27231
                            formfield = new MinovaUtil.MinovaES.UploadFile({
27232
                                allowBlank: allowblank,
27233
                                fieldLabel: rec.ScreenCaption,
27234
                                readOnly: readonly,
27235
                                readOnlyCls: 'minova-readonly',
27236
                                hidden: ishidden,
27237
                                //labelCls: 'label-minova',
27238
                                name: rec.FieldName,
27239
                                msgTarget: 'side',
27240
                                fieldname: rec.FieldName,
27241
                                IsPrimaryKey: rec.IsPrimaryKey,
27242
                                tableName: rec.TableRef,
27243
                                triggerCls: 'x-form-search-trigger',
27244
                                formtarget: me.formname,
27245
                                anchor: '100%',
27246
                                formname: formname_,
27247
                                nameTable: nameTable_,
27248
                                listeners: {
27249
                                    change: function (val) {
27250
                                        var _label = val.name;
27251
                                        var _form = val.formname;
27252
                                        var _Value = val.getValue();
27253
                                        var target = rec.TriggerCombo;
27254
                                        var custumFunc = rec.SelectFunction;
27255
                                        if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
27256
                                            Ext.Ajax.request({
27257
                                                async: false,
27258
                                                method: 'POST',
27259
                                                url: '/UserControl/GetStore',
27260
                                                params: {
27261
                                                    tableName: 'PCMFUNC',
27262
                                                    param: 'FuncName[equal]' + rec.custumFunc + ',Active[=]1'
27263
                                                },
27264
                                                success: function (response) {
27265
                                                    var results = Ext.decode(response.responseText);
27266
                                                    data_ = results.data[0];
27267
                                                    if (data_ != undefined) {
27268
                                                        custumFunc = data_.FunctionCode;
27269
                                                    }
27270
                                                }
27271
                                            });
27272
                                        }
27273
                                        var frm = Ext.ComponentQuery.query('form[name=' + _form + ']')[0];
27274
                                        if (frm) {
27275
                                            if (target) {
27276
                                                var f = frm.getForm().findField(target)
27277
                                                _store = f.getStore();
27278
                                                var _tbl = _store.proxy.extraParams.tableName;
27279
                                                var oldParam = _store.proxy.extraParams.param;
27280
                                                _store.proxy.extraParams = {
27281
                                                    tableName: _tbl,
27282
                                                    param: _label + '[=]' + _Value
27283
                                                };
27284
                                                _store.load();
27285
                                            }
27286
                                            if (custumFunc) {
27287
                                                eval(custumFunc)
27288
                                            }
27289
                                        }
27290
                                    }
27291
                                }
27292
                            });
27293
                            break;
27294
                        default:
27295
                            if (rec.DataType == 0) {
27296
                                if (rec.Length > 250) {
27297
                                    formfield = new Ext.form.TextArea({
27298
                                        allowBlank: allowblank,
27299
                                        fieldLabel: rec.ScreenCaption,
27300
                                        readOnly: readonly,
27301
                                        labelAlign: me.labelAlign,
27302
                                        labelSeparator: me.labelSeparator,
27303
                                        //labelCls: 'label-minova',
27304
                                        labelWidth: labelWidth,
27305
                                        hidden: ishidden,
27306
                                        name: rec.FieldName,
27307
                                        msgTarget: 'side',
27308
                                        value: rec.DefaultValue,
27309
                                        maxLength: rec.Length,
27310
                                        anchor: '100%',
27311
                                        grow: true,
27312
                                        formname: formname_,
27313
                                        nameTable: nameTable_,
27314
                                        listeners: {
27315
                                            change: function (val) {
27316
                                                var _label = val.name;
27317
                                                var _form = val.formname;
27318
                                                var _Value = val.getValue();
27319
                                                var target = rec.TriggerCombo;
27320
                                                var custumFunc = rec.SelectFunction;
27321
                                                if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
27322
                                                    Ext.Ajax.request({
27323
                                                        async: false,
27324
                                                        method: 'POST',
27325
                                                        url: '/UserControl/GetStore',
27326
                                                        params: {
27327
                                                            tableName: 'PCMFUNC',
27328
                                                            param: 'FuncName[equal]' + rec.custumFunc + ',Active[=]1'
27329
                                                        },
27330
                                                        success: function (response) {
27331
                                                            var results = Ext.decode(response.responseText);
27332
                                                            data_ = results.data[0];
27333
                                                            if (data_ != undefined) {
27334
                                                                custumFunc = data_.FunctionCode;
27335
                                                            }
27336
                                                        }
27337
                                                    });
27338
                                                }
27339
                                                var frm = Ext.ComponentQuery.query('form[name=' + _form + ']')[0];
27340
                                                if (frm) {
27341
                                                    if (custumFunc) {
27342
                                                        eval(custumFunc)
27343
                                                    }
27344
                                                }
27345
                                            }
27346
                                        }
27347
                                    });
27348
                                } else {
27349
                                    if (rec.FixedValue != '') {
27350
                                        var storeData = [];
27351
                                        var str = rec.FixedValue;
27352
                                        var hasil = str.split('||');
27353
                                        hasil.forEach(function (h) {
27354
                                            store_ = h.split('=')
27355
                                            storeData.push({
27356
                                                code: store_[0],
27357
                                                desc: store_[1],
27358
                                            });
27359
                                        });
27360
                                        formfield = new Ext.form.ComboBox({
27361
                                            allowBlank: allowblank,
27362
                                            fieldLabel: rec.ScreenCaption,
27363
                                            forceSelection: true,
27364
                                            readOnly: readonly,
27365
                                            //labelCls: 'label-minova',
27366
                                            labelWidth: labelWidth,
27367
                                            hidden: ishidden,
27368
                                            name: rec.FieldName,
27369
                                            msgTarget: 'side',
27370
                                            value: rec.DefaultValue,
27371
                                            anchor: '100%',
27372
                                            formname: formname_,
27373
                                            nameTable: nameTable_,
27374
                                            formtarget: me.formname,
27375
                                            store: Ext.create('Ext.data.Store', {
27376
                                                storeId: 'store' + rec.FieldName,
27377
                                                autoLoad: true,
27378
                                                data: storeData
27379

    
27380
                                            }),
27381
                                            listeners: {
27382
                                                change: function (val) {
27383
                                                    var _label = val.name;
27384
                                                    var _form = val.formtarget;
27385
                                                    var _Value = val.getValue();
27386
                                                    var target = rec.TriggerCombo;
27387
                                                    var custumFunc = rec.SelectFunction;
27388
                                                    var frm = Ext.ComponentQuery.query('form[name=' + _form + ']')[0];
27389
                                                    if (frm) {
27390
                                                        if (target) {
27391
                                                            var f = frm.getForm().findField(target)
27392
                                                            _store = f.getStore();
27393
                                                            var _tbl = _store.proxy.extraParams.tableName;
27394
                                                            var oldParam = _store.proxy.extraParams.param;
27395
                                                            _store.proxy.extraParams = {
27396
                                                                tableName: _tbl,
27397
                                                                param: _label + '[=]' + _Value
27398
                                                            };
27399
                                                            _store.load();
27400
                                                        }
27401
                                                        if (custumFunc) {
27402
                                                            eval(custumFunc)
27403
                                                        }
27404
                                                    }
27405
                                                }
27406
                                            },
27407
                                            queryMode: 'local',
27408
                                            valueField: 'code',
27409
                                            displayField: 'desc',
27410
                                        });
27411
                                    } else {
27412
                                        formfield = new Ext.form.TextField({
27413
                                            allowBlank: allowblank,
27414
                                            fieldLabel: rec.ScreenCaption,
27415
                                            readOnly: readonly,
27416
                                            //labelCls: 'label-minova',
27417
                                            labelWidth: labelWidth,
27418
                                            hidden: ishidden,
27419
                                            name: rec.FieldName,
27420
                                            msgTarget: 'side',
27421
                                            value: rec.DefaultValue,
27422
                                            maxLength: rec.Length,
27423
                                            anchor: '100%',
27424
                                            formname: formname_,
27425
                                            nameTable: nameTable_,
27426
                                            listeners: {
27427
                                                change: function (val) {
27428
                                                    var _label = val.name;
27429
                                                    var _form = val.formname;
27430
                                                    var _Value = val.getValue();
27431
                                                    var target = rec.TriggerCombo;
27432
                                                    var custumFunc = rec.SelectFunction;
27433
                                                    if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
27434
                                                        Ext.Ajax.request({
27435
                                                            async: false,
27436
                                                            method: 'POST',
27437
                                                            url: '/UserControl/GetStore',
27438
                                                            params: {
27439
                                                                tableName: 'PCMFUNC',
27440
                                                                param: 'FuncName[equal]' + rec.custumFunc + ',Active[=]1'
27441
                                                            },
27442
                                                            success: function (response) {
27443
                                                                var results = Ext.decode(response.responseText);
27444
                                                                data_ = results.data[0];
27445
                                                                if (data_ != undefined) {
27446
                                                                    custumFunc = data_.FunctionCode;
27447
                                                                }
27448
                                                            }
27449
                                                        });
27450
                                                    }
27451
                                                    var frm = Ext.ComponentQuery.query('form[name=' + _form + ']')[0];
27452
                                                    if (frm) {
27453
                                                        if (custumFunc) {
27454
                                                            eval(custumFunc)
27455
                                                        }
27456
                                                    }
27457
                                                }
27458
                                            }
27459
                                        });
27460
                                    }
27461
                                }
27462
                            } else if (rec.DataType == 1 || rec.DataType == 2) {
27463
                                formfield = new MinovaUtil.MinovaES.MinovaNumberField({
27464
                                    allowBlank: allowblank,
27465
                                    fieldLabel: rec.ScreenCaption,
27466
                                    readOnly: readonly,
27467
                                    //labelCls: 'label-minova',
27468
                                    labelWidth: labelWidth,
27469
                                    msgTarget: 'side',
27470
                                    hidden: ishidden,
27471
                                    name: rec.FieldName,
27472
                                    value: rec.DefaultValue,
27473
                                    maxLength: rec.Length,
27474
                                    anchor: '100%',
27475
                                    formname: formname_,
27476
                                    nameTable: nameTable_,
27477
                                    fieldStyle: 'text-align:right;',
27478
                                    listeners: {
27479
                                        change: function (val) {
27480
                                            var _label = val.name;
27481
                                            var _form = val.formname;
27482
                                            var _Value = val.getValue();
27483
                                            var target = rec.TriggerCombo;
27484
                                            var custumFunc = rec.SelectFunction;
27485
                                            if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
27486
                                                Ext.Ajax.request({
27487
                                                    async: false,
27488
                                                    method: 'POST',
27489
                                                    url: '/UserControl/GetStore',
27490
                                                    params: {
27491
                                                        tableName: 'PCMFUNC',
27492
                                                        param: 'FuncName[equal]' + rec.custumFunc + ',Active[=]1'
27493
                                                    },
27494
                                                    success: function (response) {
27495
                                                        var results = Ext.decode(response.responseText);
27496
                                                        data_ = results.data[0];
27497
                                                        if (data_ != undefined) {
27498
                                                            custumFunc = data_.FunctionCode;
27499
                                                        }
27500
                                                    }
27501
                                                });
27502
                                            }
27503
                                            var frm = Ext.ComponentQuery.query('form[name=' + _form + ']')[0];
27504
                                            if (frm) {
27505
                                                if (target) {
27506
                                                    var f = frm.getForm().findField(target)
27507
                                                    _store = f.getStore();
27508
                                                    var _tbl = _store.proxy.extraParams.tableName;
27509
                                                    var oldParam = _store.proxy.extraParams.param;
27510
                                                    _store.proxy.extraParams = {
27511
                                                        tableName: _tbl,
27512
                                                        param: _label + '[=]' + _Value
27513
                                                    };
27514
                                                    _store.load();
27515
                                                }
27516
                                                if (custumFunc) {
27517
                                                    eval(custumFunc)
27518
                                                }
27519
                                            }
27520
                                        }
27521
                                    }
27522
                                });
27523
                            } else if (rec.DataType == 3) {
27524
                                formfield = new Ext.form.TextField({
27525
                                    allowBlank: allowblank,
27526
                                    fieldLabel: rec.ScreenCaption,
27527
                                    readOnly: readonly,
27528
                                    //labelCls: 'label-minova',
27529
                                    labelWidth: labelWidth,
27530
                                    msgTarget: 'side',
27531
                                    hidden: ishidden,
27532
                                    name: rec.FieldName,
27533
                                    value: rec.DefaultValue,
27534
                                    maxLength: rec.Length,
27535
                                    precision: rec.Prec,
27536
                                    anchor: '100%',
27537
                                    formname: formname_,
27538
                                    nameTable: nameTable_,
27539
                                    fieldStyle: 'text-align:right;',
27540
                                    maskRe: '^[0-9]+(\.[0-9]{1,2})?$',
27541
                                    listeners: {
27542
                                        change: function (val) {
27543
                                            var _label = val.name;
27544
                                            var _form = val.formname;
27545
                                            var _Value = val.getValue();
27546
                                            var target = rec.TriggerCombo;
27547
                                            var custumFunc = rec.SelectFunction;
27548
                                            if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
27549
                                                Ext.Ajax.request({
27550
                                                    async: false,
27551
                                                    method: 'POST',
27552
                                                    url: '/UserControl/GetStore',
27553
                                                    params: {
27554
                                                        tableName: 'PCMFUNC',
27555
                                                        param: 'FuncName[equal]' + rec.custumFunc + ',Active[=]1'
27556
                                                    },
27557
                                                    success: function (response) {
27558
                                                        var results = Ext.decode(response.responseText);
27559
                                                        data_ = results.data[0];
27560
                                                        if (data_ != undefined) {
27561
                                                            custumFunc = data_.FunctionCode;
27562
                                                        }
27563
                                                    }
27564
                                                });
27565
                                            }
27566
                                            var frm = Ext.ComponentQuery.query('form[name=' + _form + ']')[0];
27567
                                            if (frm) {
27568
                                                if (target) {
27569
                                                    var f = frm.getForm().findField(target)
27570
                                                    _store = f.getStore();
27571
                                                    var _tbl = _store.proxy.extraParams.tableName;
27572
                                                    var oldParam = _store.proxy.extraParams.param;
27573
                                                    _store.proxy.extraParams = {
27574
                                                        tableName: _tbl,
27575
                                                        param: _label + '[=]' + _Value
27576
                                                    };
27577
                                                    _store.load();
27578
                                                }
27579
                                                if (custumFunc) {
27580
                                                    eval(custumFunc)
27581
                                                }
27582
                                            }
27583
                                        }
27584
                                    }
27585
                                });
27586
                            }
27587
                    }
27588
                } else if (rec.SearchType != "") {
27589
                    if (rec.SearchType == "0") //combobox
27590
                    {
27591
                        valueField = null;
27592
                        displayValue = null;
27593
                        if (rec.TableRef != "") {
27594
                            Ext.Ajax.request({
27595
                                async: false,
27596
                                method: 'POST',
27597
                                url: '/UserControl/GetStore',
27598
                                params: {
27599
                                    tableName: 'SDATATABLEFIELD',
27600
                                    param: 'TableName[equal]' + rec.TableRef
27601
                                },
27602
                                success: function (response) {
27603
                                    var results = Ext.decode(response.responseText);
27604
                                    data_ = results.data;
27605
                                    if (data_ != undefined) {
27606
                                        valueField_ = $.grep(data_, function (r) {
27607
                                            return r.ValueField == '1'
27608
                                        });
27609
                                        if (valueField_.length > 0) {
27610
                                            valueField = valueField_[0].FieldName
27611
                                        }
27612
                                        displayValue_ = $.grep(data_, function (r) {
27613
                                            return r.DisplayValue == '1'
27614
                                        });
27615
                                        if (displayValue_.length > 0) {
27616
                                            displayValue = displayValue_[0].FieldName
27617
                                        }
27618
                                    }
27619
                                }
27620
                            });
27621
                        }
27622
                        formfield = new Ext.form.ComboBox({
27623
                            allowBlank: allowblank,
27624
                            fieldLabel: rec.ScreenCaption,
27625
                            forceSelection: true,
27626
                            anyMatch: true,
27627
                            readOnly: readonly,
27628
                            //labelCls: 'label-minova',
27629
                            labelWidth: labelWidth,
27630
                            hidden: ishidden,
27631
                            msgTarget: 'side',
27632
                            name: rec.FieldName,
27633
                            formname: formname_,
27634
                            nameTable: nameTable_,
27635
                            value: rec.DefaultValue,
27636
                            anchor: '100%',
27637
                            store: Ext.create('Ext.data.Store', {
27638
                                storeId: 'store' + rec.FieldName,
27639
                                autoLoad: false,
27640
                                proxy: {
27641
                                    method: 'POST',
27642
                                    type: 'ajax',
27643
                                    url: '/UserControl/GetStore',
27644
                                    extraParams: {
27645
                                        tableName: rec.TableRef,
27646
                                        param: rec.ParamCombo
27647
                                    },
27648
                                    reader: {
27649
                                        type: 'json',
27650
                                        root: 'data',
27651
                                        totalProperty: 'data[0].TotalCount'
27652
                                    }
27653
                                }
27654
                            }),                            
27655
                            formtarget: formname_,
27656
                            listeners: {
27657
                                afterrender: function (f) {
27658
                                    var store_ = f.getStore();
27659
                                    store_.load();
27660
                                },
27661
                                change: function (val) {
27662
                                    var _label = val.name;
27663
                                    var _form = val.formtarget;
27664
                                    var _Value = val.getValue();
27665
                                    var target = rec.TriggerCombo;
27666
                                    var custumFunc = rec.SelectFunction;
27667
                                    var frm = Ext.ComponentQuery.query('form[name=' + _form + ']')[0];
27668
                                    if (frm) {
27669

    
27670
                                        if (target) {
27671
                                            var f = frm.getForm().findField(target)
27672
                                            _store = f.getStore();
27673
                                            var _tbl = _store.proxy.extraParams.tableName;
27674
                                            var oldParam = _store.proxy.extraParams.param;
27675
                                            _store.proxy.extraParams = {
27676
                                                tableName: _tbl,
27677
                                                param: _label + '[=]' + _Value
27678
                                            };
27679
                                            _store.load();
27680
                                        }
27681
                                        if (custumFunc) {
27682
                                            eval(custumFunc)
27683
                                        }
27684
                                    }
27685
                                }
27686
                            },
27687
                            queryMode: 'local',
27688
                            displayField: displayValue,
27689
                            valueField: valueField,
27690
                        });
27691
                    } else if (rec.SearchType == '2') //Lookup
27692
                    {
27693
                        formfield = new MinovaUtil.MinovaES.MinovaLookupGrid({
27694
                            allowBlank: allowblank,
27695
                            fieldLabel: rec.ScreenCaption,
27696
                            readOnly: readonly,
27697
                            IsPrimaryKey: rec.IsPrimaryKey,
27698
                            msgTarget: 'side',
27699
                            //labelCls: 'label-minova',
27700
                            labelWidth: labelWidth,
27701
                            hidden: ishidden,
27702
                            name: rec.FieldName,
27703
                            tableName: rec.TableRef, //name tabel yang jadi ref-nya
27704
                            triggerCls: 'x-form-search-trigger',
27705
                            vtype: 'alphanum', // disable space
27706
                            formtarget: me.formname, // nama form  yang akan di set value-nya
27707
                            anchor: '100%',
27708
                            formname: formname_,
27709
                            nameTable: nameTable_,
27710
                            LookupFunction: rec.LookupFunction,
27711
                            SearchFunction: rec.SearchFunction,
27712
                            listeners: {
27713
                                change: function (val) {
27714
                                    var _label = val.name;
27715
                                    var _form = val.formname;
27716
                                    var _Value = val.getValue();
27717
                                    var target = rec.TriggerCombo;
27718
                                    var custumFunc = rec.SelectFunction;
27719
                                    if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
27720
                                        Ext.Ajax.request({
27721
                                            async: false,
27722
                                            method: 'POST',
27723
                                            url: '/UserControl/GetStore',
27724
                                            params: {
27725
                                                tableName: 'PCMFUNC',
27726
                                                param: 'FuncName[equal]' + rec.custumFunc + ',Active[=]1'
27727
                                            },
27728
                                            success: function (response) {
27729
                                                var results = Ext.decode(response.responseText);
27730
                                                data_ = results.data[0];
27731
                                                if (data_ != undefined) {
27732
                                                    custumFunc = data_.FunctionCode;
27733
                                                }
27734
                                            }
27735
                                        });
27736
                                    }
27737
                                    var frm = Ext.ComponentQuery.query('form[name=' + _form + ']')[0];
27738
                                    if (frm) {
27739

    
27740
                                        if (target) {
27741
                                            var f = frm.getForm().findField(target)
27742
                                            _store = f.getStore();
27743
                                            var _tbl = _store.proxy.extraParams.tableName;
27744
                                            var oldParam = _store.proxy.extraParams.param;
27745
                                            _store.proxy.extraParams = {
27746
                                                tableName: _tbl,
27747
                                                param: _label + '[=]' + _Value
27748
                                            };
27749
                                            _store.load();
27750
                                        }
27751

    
27752
                                        if (custumFunc) {
27753
                                            eval(custumFunc)
27754
                                        }
27755

    
27756
                                    }
27757

    
27758
                                },
27759

    
27760
                            },
27761
                        });
27762
                    } else if (rec.SearchType == '3') //lookup tree
27763
                    {
27764
                        formfield = new MinovaUtil.MinovaES.MinovaLookupTree({
27765
                            allowBlank: allowblank,
27766
                            fieldLabel: rec.ScreenCaption,
27767
                            readOnly: readonly,
27768
                            IsPrimaryKey: rec.IsPrimaryKey,
27769
                            //labelCls: 'label-minova',
27770
                            labelWidth: labelWidth,
27771
                            hidden: ishidden,
27772
                            name: rec.FieldName,
27773
                            msgTarget: 'side',
27774
                            triggerCls: 'x-form-search-trigger',
27775
                            treeSructure: rec.SearchFunction, //'O-O-P',
27776
                            objClassValue: rec.ParamCombo, //'O',
27777
                            formname: formname_,
27778
                            targetField: rec.FieldName,
27779
                            nameTable: nameTable_,
27780
                            editable: false,
27781
                            anchor: '100%',
27782
                            listeners: {
27783
                                change3: function (val) {
27784
                                    var _label = val.name;
27785
                                    var _form = val.formname;
27786
                                    var _Value = val.getValue();
27787
                                    var target = rec.TriggerCombo;
27788
                                    var custumFunc = rec.SelectFunction;
27789
                                    if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
27790
                                        Ext.Ajax.request({
27791
                                            async: false,
27792
                                            method: 'POST',
27793
                                            url: '/UserControl/GetStore',
27794
                                            params: {
27795
                                                tableName: 'PCMFUNC',
27796
                                                param: 'FuncName[equal]' + rec.custumFunc + ',Active[=]1'
27797
                                            },
27798
                                            success: function (response) {
27799
                                                var results = Ext.decode(response.responseText);
27800
                                                data_ = results.data[0];
27801
                                                if (data_ != undefined) {
27802
                                                    custumFunc = data_.FunctionCode;
27803
                                                }
27804
                                            }
27805
                                        });
27806
                                    }
27807
                                    var frm = Ext.ComponentQuery.query('form[name=' + _form + ']')[0];
27808
                                    if (frm) {
27809

    
27810
                                        if (target) {
27811
                                            var f = frm.getForm().findField(target)
27812
                                            _store = f.getStore();
27813
                                            var _tbl = _store.proxy.extraParams.tableName;
27814
                                            var oldParam = _store.proxy.extraParams.param;
27815
                                            _store.proxy.extraParams = {
27816
                                                tableName: _tbl,
27817
                                                param: _label + '[=]' + _Value
27818
                                            };
27819
                                            _store.load();
27820
                                        }
27821
                                        if (custumFunc) {
27822
                                            eval(custumFunc)
27823
                                        }
27824
                                    }
27825
                                },
27826
                                blur: function (val) {
27827
                                    //if(val.value.split('-').length != 2){
27828
                                    var _label = val.name;
27829
                                    var _form = val.formname;
27830
                                    var _Value = val.getValue();
27831
                                    var target = rec.TriggerCombo;
27832
                                    var custumFunc = rec.SelectFunction;
27833
                                    if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
27834
                                        Ext.Ajax.request({
27835
                                            async: false,
27836
                                            method: 'POST',
27837
                                            url: '/UserControl/GetStore',
27838
                                            params: {
27839
                                                tableName: 'PCMFUNC',
27840
                                                param: 'FuncName[equal]' + rec.custumFunc + ',Active[=]1'
27841
                                            },
27842
                                            success: function (response) {
27843
                                                var results = Ext.decode(response.responseText);
27844
                                                data_ = results.data[0];
27845
                                                if (data_ != undefined) {
27846
                                                    custumFunc = data_.FunctionCode;
27847
                                                }
27848
                                            }
27849
                                        });
27850
                                    }
27851
                                    var frm = Ext.ComponentQuery.query('form[name=' + _form + ']')[0];
27852
                                    if (frm) {
27853

    
27854
                                        if (target) {
27855
                                            var f = frm.getForm().findField(target)
27856
                                            _store = f.getStore();
27857
                                            var _tbl = _store.proxy.extraParams.tableName;
27858
                                            var oldParam = _store.proxy.extraParams.param;
27859
                                            _store.proxy.extraParams = {
27860
                                                tableName: _tbl,
27861
                                                param: _label + '[=]' + _Value
27862
                                            };
27863
                                            _store.load();
27864
                                        }
27865
                                        if (custumFunc) {
27866
                                            eval(custumFunc)
27867
                                        }
27868
                                    }
27869
                                    //}
27870
                                }
27871

    
27872
                            }
27873
                        });
27874
                    } else if (rec.SearchType == '10') //Checkboxgroup
27875
                    {
27876
                        if (rec.TableRef != "") {
27877
                            Ext.Ajax.request({
27878
                                async: false,
27879
                                method: 'POST',
27880
                                url: '/UserControl/GetStore',
27881
                                params: {
27882
                                    tableName: 'SDATATABLEFIELD',
27883
                                    param: 'TableName[equal]' + rec.TableRef
27884
                                },
27885
                                success: function (response) {
27886
                                    var results = Ext.decode(response.responseText);
27887
                                    data_ = results.data;
27888
                                    if (data_ != undefined) {
27889
                                        valueField_ = $.grep(data_, function (r) {
27890
                                            return r.ValueField == '1'
27891
                                        });
27892
                                        if (valueField_.length > 0) {
27893
                                            valueField = valueField_[0].FieldName
27894
                                        }
27895
                                        displayValue_ = $.grep(data_, function (r) {
27896
                                            return r.DisplayValue == '1'
27897
                                        });
27898
                                        if (displayValue_.length > 0) {
27899
                                            displayValue = displayValue_[0].FieldName
27900
                                        }
27901
                                    }
27902
                                }
27903
                            });
27904
                        }
27905
                        formfield = new MinovaUtil.MinovaES.StoreCheckboxGroup({
27906
                            //xtype: 'storecheckboxgroup',
27907
                            //allowBlank: allowblank,
27908
                            name: 'cbg' + rec.FieldName,
27909
                            nametxt: rec.FieldName,
27910
                            formname: formname_,
27911
                            nameTable: nameTable_,
27912
                            value: rec.DefaultValue,
27913
                            fieldLabel: rec.ScreenCaption,
27914
                            labelAlign: me.labelAlign,
27915
                            labelSeparator: me.labelSeparator,
27916
                            readOnly: readonly,
27917
                            //forceSelection: true,
27918
                            //anyMatch: true,
27919
                            //readOnly: readonly,
27920
                            ////labelCls: 'label-minova',
27921
                            labelWidth: labelWidth,
27922
                            //hidden: ishidden,
27923
                            //msgTarget: 'side',
27924
                            //name: rec.FieldName,
27925
                            //formname: formname_,
27926
                            //nameTable: nameTable_,
27927
                            //value: rec.DefaultValue,
27928
                            //width: '95%',
27929
                            store: Ext.create('Ext.data.Store', {
27930
                                storeId: 'store' + rec.FieldName,
27931
                                autoLoad: true,
27932
                                proxy: {
27933
                                    method: 'POST',
27934
                                    type: 'ajax',
27935
                                    url: '/UserControl/GetStore',
27936
                                    extraParams: {
27937
                                        tableName: rec.TableRef,
27938
                                        param: rec.ParamCombo
27939
                                    },
27940
                                    reader: {
27941
                                        type: 'json',
27942
                                        root: 'data',
27943
                                        totalProperty: 'data[0].TotalCount'
27944
                                    }
27945
                                }
27946
                            }),
27947
                            //formtarget: formname_,
27948
                            columns: 2,
27949
                            vertical: true,
27950
                            mapFn: function (storeItem) {
27951
                                var txfield = Ext.ComponentQuery.query('[name=' + rec.FieldName + '_TX_' + storeItem.data.ProblemCode + ']')[0];
27952
                                var txvalue = '';
27953
                                if (txfield) txvalue = txfield.value;
27954
                                var cbfield = Ext.ComponentQuery.query('[name=' + rec.FieldName + '_CB_' + storeItem.data.ProblemCode + ']')[0];
27955
                                var cbchecked = false;
27956
                                if (cbfield) cbchecked = (cbfield.value === 'true');
27957
                                return {
27958
                                    // Here, we define which store fields map 
27959
                                    // to which checkbox configuration property.
27960
                                    // The field "label" should map to boxLabel
27961
                                    // The field "value" should map to inputValue
27962
                                    // xtype and name are hardcoded for all checkboxes in this group.
27963
                                    xtype: 'container',
27964
                                    items: [
27965
                                        {
27966
                                            xtype: 'checkbox',
27967
                                            boxLabel: storeItem.data.ProblemDesc,
27968
                                            name: 'cb_' + rec.FieldName + '_CB_' + storeItem.data.ProblemCode,
27969
                                            nametxt: rec.FieldName + '_CB_' + storeItem.data.ProblemCode,
27970
                                            formname: formname_,
27971
                                            nameTable: nameTable_,
27972
                                            readOnly: readonly,
27973
                                            isshowtext: storeItem.data.IsShowText,
27974
                                            inputValue: storeItem.data.ProblemCode,
27975
                                            checked: cbchecked,
27976
                                            listeners: {
27977
                                                click: {
27978
                                                    element: 'el', //bind to the underlying el property on the panel
27979
                                                    fn: function (id) {
27980
                                                        var MyComp = Ext.getCmp(this.id);
27981
                                                        var frmForm = Ext.ComponentQuery.query('[name=tx_' + this.el.component.nametxt.replace("_CB_", "_TX_") + ']')[0];
27982
                                                        if (this.el.component.isshowtext == '1') {
27983
                                                            frmForm.setHidden(!MyComp.checked);
27984
                                                            frmForm.setValue('');
27985
                                                        }
27986
                                                        var cb_ = Ext.ComponentQuery.query('[name=' + this.el.component.nametxt + ']')[0];
27987
                                                        cb_.setValue(MyComp.checked);
27988
                                                    }
27989
                                                },
27990
                                                //change: function (val) {
27991
                                                //    alert('ok');
27992
                                                //},
27993
                                            }
27994
                                        }, {
27995
                                            xtype: 'textareafield',
27996
                                            name: 'tx_' + rec.FieldName + '_TX_' + storeItem.data.ProblemCode,
27997
                                            nametxt: rec.FieldName + '_TX_' + storeItem.data.ProblemCode,
27998
                                            formname: formname_,
27999
                                            nameTable: nameTable_,
28000
                                            readOnly: readonly,
28001
                                            width: '100%',
28002
                                            value: txvalue,
28003
                                            hidden: !((storeItem.data.IsShowText === '1') && (cbchecked)),
28004
                                            listeners: {
28005
                                                change: function (id, newValue, oldValue, eOpts) {
28006
                                                    var frmForm = Ext.ComponentQuery.query('[name=' + id.nametxt + ']')[0];
28007
                                                    frmForm.setValue(newValue);
28008
                                                },
28009
                                            }
28010
                                        }]
28011
                                };
28012
                            }
28013
                        });
28014
                    } else if (rec.SearchType == '11') //Checkbox
28015
                    {
28016
                        formfield = new Ext.Container({
28017
                            items: [
28018
                                {
28019
                                    xtype: 'checkbox',
28020
                                    boxLabel: rec.ScreenCaption,
28021
                                    name: 'cb_' + rec.FieldName,
28022
                                    nametxt: rec.FieldName,
28023
                                    hidden: ishidden,
28024
                                    readOnly: readonly,
28025
                                    tableName: rec.TableRef, //name tabel yang jadi ref-nya
28026
                                    checked: (rec.DefaultValue.toUpperCase() === 'TRUE'),
28027
                                    listeners: {
28028
                                        click: {
28029
                                            element: 'el', //bind to the underlying el property on the panel
28030
                                            fn: function (id) {
28031
                                                var MyComp = Ext.getCmp(this.id);
28032
                                                var frmForm = Ext.ComponentQuery.query('[name=' + this.el.component.nametxt + ']')[0];
28033
                                                frmForm.setValue(MyComp.checked);
28034
                                            }
28035
                                        }
28036
                                    }
28037
                                },
28038
                                {
28039
                                    xtype: 'textfield',
28040
                                    name: rec.FieldName,
28041
                                    namecb: 'cb_' + rec.FieldName,
28042
                                    formname: formname_,
28043
                                    nameTable: nameTable_,
28044
                                    readOnly: readonly,
28045
                                    value: rec.DefaultValue,
28046
                                    hidden: true,
28047
                                    listeners: {
28048
                                        change: function (id, newValue, oldValue, eOpts) {
28049
                                            var cbfield = Ext.ComponentQuery.query('[name=' + id.namecb + ']')[0];
28050
                                            var cbchecked = false;
28051
                                            if (cbfield) cbchecked = (newValue === 'true');
28052
                                            cbfield.setValue(cbchecked);
28053
                                        },
28054
                                    }
28055
                                }]
28056
                            
28057
                        })
28058
                        //formfield = new Ext.form.field.Checkbox({
28059
                        //    boxLabel: rec.ScreenCaption,
28060
                        //    name: rec.FieldName,
28061
                        //    name: 'cb_' + rec.FieldName,
28062
                        //    nametxt: rec.FieldName,
28063
                        //    hidden: ishidden,
28064
                        //    readOnly: readonly,
28065
                        //    name: rec.FieldName,
28066
                        //    tableName: rec.TableRef, //name tabel yang jadi ref-nya
28067
                        //    checked: (rec.DefaultValue.toUpperCase() === 'TRUE'),
28068
                        //    listeners: {
28069
                        //        click: {
28070
                        //            element: 'el', //bind to the underlying el property on the panel
28071
                        //            fn: function (id) {
28072
                        //                var MyComp = Ext.getCmp(this.id);
28073
                        //                var cb_ = Ext.ComponentQuery.query('[name=' + this.el.component.nametxt + ']')[0];
28074
                        //                cb_.setValue(MyComp.checked);
28075
                        //            }
28076
                        //        }
28077
                        //    }
28078
                        //    //value: rec.DefaultValue,
28079
                        //})
28080
                    }
28081
                }
28082
                if (isDesk) {
28083
                    if (rec.ColumnNo == 1) {
28084
                        col1.push(formfield);
28085
                    } else if (rec.ColumnNo == 2) {
28086
                        col2.push(formfield);
28087
                    } else {
28088
                        col0.push(formfield);
28089
                    }
28090
                } else {
28091
                    if (rec.ColumnNo == 1 || rec.ColumnNo == 2) {
28092
                        col1.push(formfield);
28093
                    } else {
28094
                        col0.push(formfield);
28095
                    }
28096
                }
28097

    
28098
            });
28099
        }
28100
        Ext.applyIf(me, {
28101
            items:
28102
                [
28103
                    {
28104
                        //width: 450,
28105
                        //style: 'width: 50%',
28106
                        defaults: {
28107
                            layout: 'anchor',
28108
                            xtype: 'container',
28109
                            flex: 1,
28110
                            margin: me.marginDefault,
28111
                            //defaultType: 'textfield',
28112
                            //anchor: '100%',
28113
                            ////style: 'width: 50%',
28114
                        },
28115
                        items: col1,
28116
                        flex: 1,
28117
                    },
28118
                    {
28119
                        //width: 450,
28120
                        //style: 'width: 50%',
28121
                        defaults: {
28122
                            layout: 'anchor',
28123
                            xtype: 'container',
28124
                            flex: 1,
28125
                            margin: me.marginDefault,
28126
                            //defaultType: 'textfield',
28127
                            //anchor: '100%',
28128
                            ////style: 'width: 50%',
28129
                        },
28130
                        items: col2,
28131
                        flex: 1,
28132
                    },
28133
                    {
28134
                        items: col0,
28135
                        flex: 0,
28136
                        hidden: true
28137
                    }
28138
                ]
28139
        });
28140
        this.callParent();
28141
    }
28142
});
28143

    
28144
/*EditableGrid ESS Generator YN 20211216 */
28145
Ext.define('MinovaUtil.MinovaES.MinovaWorkflowEditableGrid2', {
28146
    extend: 'Ext.form.Panel',
28147
    alias: ['widget.minovaworkfloweditablegrid2', 'widget.workfloweditablegrid2'],
28148
    requires: [
28149
        'Ext.grid.plugin.CellEditing',
28150
        'Ext.grid.RowNumberer',
28151
        'Ext.grid.Panel',
28152
    ],
28153
    cls: 'grid-ess',
28154
    anchor: '100%',
28155
    tableName: undefined,
28156
    hideButton: undefined,
28157
    multiSelect: undefined,
28158
    formname: this.name,
28159
    bizprocid: undefined,
28160
    bizflowid: undefined,
28161
    taskid: undefined,
28162
    features: undefined,
28163
    minHeight: undefined,
28164
    maxHeight: undefined,
28165
    headerLayout: undefined,
28166
    summaryType: undefined,
28167
    initComponent: function () {
28168
        var me = this;
28169
        var isLookup = me.isLookup;
28170
        var hide_ = false;
28171
        var widthLock = 250;
28172
        var checkSelection = '';
28173
        if (me.hideButton == true) {
28174
            hide_ = true;
28175
        }
28176
        if (me.multiSelect) {
28177
            locking = false;
28178
            checkSelection = 'checkboxmodel';
28179
            widthLock = 40;
28180
        }
28181
        var tableName = me.tableName;
28182
        var features = me.features;
28183
        var cols = [];
28184
        var fieldStore = [];
28185
        var _url = 'GetAllField';
28186
        var hasil = null;
28187
        var height = me.height;
28188
        var storeID = 'store' + me.tableName;
28189
        var gridName = 'grid' + me.name;
28190
        if (me.storeName) {
28191
            storeID = me.storeName;
28192
        }
28193
        var LangID = MinovaUtil.GetLangID();
28194
        var parameter = "LangID='" + LangID + "',BizProcessID='" + me.bizprocid + "',TaskID='" + me.taskid + "',TableName='" + me.tableName + "'";
28195
        Ext.Ajax.request({
28196
            async: false,
28197
            method: 'POST',
28198
            url: '/UserControl/GetStore',
28199
            params: {
28200
                tableName: 'PDSWFSTRUCTUREFIELD',
28201
                param: parameter
28202
            },
28203
            success: function (response) {
28204
                var results = Ext.decode(response.responseText);
28205
                hasil = results.data;
28206
            }
28207
        });
28208
        cols.push({
28209
            xtype: 'rownumberer'
28210
        });
28211
        var addData = 'var data={';
28212
        if (hasil.length > 0) {
28213
            Ext.each(hasil, function (rec) {
28214
                fieldStore.push(rec.FieldName);
28215
                if (rec.FieldName != 'Sequence') {
28216
                    addData = addData + rec.FieldName + ":" + "'',";
28217
                }
28218
                var null_ = null;
28219
                var ReadOnly_ = false;
28220
                if (rec.IsRequired == '1') {
28221
                    null_ = false;
28222
                } else {
28223
                    null_ = true;
28224
                }
28225
                var Hidden_ = false;
28226
                if (rec.IsReadOnly == '1') {
28227
                    ReadOnly_ = true;
28228
                }
28229
                if (rec.IsVisible == '1') {
28230
                    switch (rec.FormatRef) {
28231
                        case "date":
28232
                            cols.push({
28233
                                xtype: 'minovadatecolumn',
28234
                                hidden: Hidden_,
28235
                                text: rec.HeaderTitle,
28236
                                dataIndex: rec.FieldName,
28237
                                filter: {
28238
                                    itemDefaults: {
28239
                                        emptyText: 'Search for...',
28240
                                    }
28241
                                },
28242
                                editor: {
28243
                                    allowBlank: null_,
28244
                                    xtype: 'datefield',
28245
                                    hideMode: 'visibility',
28246
                                    readOnly: ReadOnly_,
28247
                                    id: tableName + rec.FieldName,
28248
                                    fieldGrid: rec.FieldName,
28249
                                    nameTable: rec.TableName,
28250
                                    value: rec.DefaultValue
28251
                                }
28252
                            });
28253
                            break
28254
                        case "amount":
28255
                            cols.push({
28256
                                xtype: 'minovacurrancycolumn',
28257
                                align: 'right',
28258
                                text: rec.HeaderTitle,
28259
                                dataIndex: rec.FieldName,
28260
                                hidden: Hidden_,
28261
                                filter: {
28262
                                    itemDefaults: {
28263
                                        emptyText: 'Search for...'
28264
                                    }
28265
                                },
28266
                                editor: {
28267
                                    allowBlank: null_,
28268
                                    xtype: 'minovacurrencyfield',
28269
                                    readOnly: ReadOnly_,
28270
                                    id: tableName + rec.FieldName,
28271
                                    nameTable: rec.TableName,
28272
                                    fieldGrid: rec.FieldName,
28273
                                    fieldStyle: 'text-align:right;',
28274
                                    value: '0',
28275
                                    maxLength: rec.Length,
28276
                                }
28277
                            });
28278
                            break
28279
                        default:
28280
                            if (rec.DataRef == 'CREATEBY' || rec.DataRef == 'CHANGEBY' || rec.DataRef == 'CREATEDT' || rec.DataRef == 'CHANGEDT') {
28281
                                cols.push({
28282
                                    text: rec.HeaderTitle,
28283
                                    dataIndex: rec.FieldName,
28284
                                    width: 100,
28285
                                    filter: {
28286
                                        type: 'string',
28287
                                        itemDefaults: {
28288
                                            emptyText: 'Search for...'
28289
                                        }
28290
                                    }
28291
                                });
28292
                            } else if (rec.SearchType == '0') {
28293
                                var valueField = null;
28294
                                var displayValue = null;
28295
                                var TableRef = undefined;
28296
                                if (rec.TableRef != '') {
28297
                                    TableRef = rec.TableRef;
28298
                                    Ext.Ajax.request({
28299
                                        async: false,
28300
                                        method: 'POST',
28301
                                        url: '/UserControl/GetStore',
28302
                                        params: {
28303
                                            tableName: 'SDATATABLEFIELD',
28304
                                            param: 'TableName[equal]' + rec.TableRef
28305
                                        },
28306
                                        success: function (response) {
28307
                                            var results = Ext.decode(response.responseText);
28308
                                            data_ = results.data;
28309
                                            if (data_ != undefined) {
28310
                                                valueField_ = $.grep(data_, function (r) {
28311
                                                    return r.ValueField == '1'
28312
                                                });
28313
                                                valueField = valueField_[0].FieldName
28314
                                                displayValue_ = $.grep(data_, function (r) {
28315
                                                    return r.DisplayValue == '1'
28316
                                                });
28317
                                                displayValue = displayValue_[0].FieldName
28318
                                            }
28319
                                        }
28320
                                    });
28321
                                }
28322
                                Ext.create('Ext.data.Store', {
28323
                                    storeId: 'store_' + me.tableName + rec.FieldName,
28324
                                    autoLoad: true,
28325
                                    proxy: {
28326
                                        method: 'POST',
28327
                                        type: 'ajax',
28328
                                        url: '/UserControl/GetStoreAuth',
28329
                                        extraParams: {
28330
                                            tableName: TableRef,
28331
                                            param: rec.ParamCombo,
28332
                                            menuId: MinovaUtil.GetMenuID()
28333
                                        },
28334
                                        reader: {
28335
                                            type: 'json',
28336
                                            root: 'data',
28337
                                            totalProperty: 'data[0].TotalCount'
28338
                                        }
28339
                                    }
28340
                                });
28341
                                cols.push({
28342
                                    //xtype : 'minovacombocolumn',
28343
                                    hidden: Hidden_,
28344
                                    text: rec.HeaderTitle,
28345
                                    dataIndex: rec.FieldName,
28346
                                    width: (rec.Length * 6.5 + 20) > 300 ? 300 : rec.Length * 6.5 + 30,
28347
                                    summaryType: function (records) {
28348
                                        var suma = 0;
28349
                                        if (me.summaryType == 'average') {
28350
                                            // Sumar en la columna solo las lineas que estan marcadas para ser sumadas a los totales
28351
                                            Ext.each(records, function (record, index) {
28352
                                                if (record.get(rec.FieldName)) {
28353
                                                    suma = suma + parseFloat(record.get(rec.FieldName).replace(",", "."));
28354
                                                }
28355
                                            });
28356
                                            (records.length == 0) ? suma = 0 : suma = suma / records.length;
28357
                                        }
28358
                                        else if (me.summaryType == 'sum') {
28359
                                            // Sumar en la columna solo las lineas que estan marcadas para ser sumadas a los totales
28360
                                            Ext.each(records, function (record, index) {
28361
                                                if (record.get(rec.FieldName)) {
28362
                                                    suma = suma + parseFloat(record.get(rec.FieldName).replace(",", "."));
28363
                                                }
28364
                                            });
28365
                                        }
28366
                                        return suma;
28367
                                    },
28368
                                    //valueField : valueField,
28369
                                    //displayField : displayValue,
28370
                                    //store : 'store_' + me.tableName + rec.FieldName,
28371
                                    editor: {
28372
                                        allowBlank: null_,
28373
                                        xtype: 'minovacombobox',
28374
                                        readOnly: ReadOnly_,
28375
                                        id: rec.TableName + rec.FieldName,
28376
                                        nameTable: rec.TableName,
28377
                                        fieldGrid: rec.FieldName,
28378
                                        valueField: valueField,
28379
                                        displayField: displayValue,
28380
                                        store: 'store_' + me.tableName + rec.FieldName,
28381
                                        value: rec.DefaultValue
28382
                                    },
28383
                                    renderer: function (value) {
28384
                                        var store = Ext.data.StoreManager.lookup('store_' + me.tableName + rec.FieldName);
28385
                                        var index = store.find(valueField, value);
28386
                                        var val = "";
28387
											//SASWANTO 6JULI2022 BEGIN
28388
										var custumFunc = rec.SelectFunction;
28389
										if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
28390
											Ext.Ajax.request({
28391
												async: false,
28392
												method: 'POST',
28393
												url: '/UserControl/GetStore',
28394
												params: {
28395
													tableName: 'PCMFUNC',
28396
													param: 'FuncName[equal]' + custumFunc + ',Active[=]1'
28397
												},
28398
												success: function (response) {
28399
													var results = Ext.decode(response.responseText);
28400
													data_ = results.data[0];
28401
													if (data_ != undefined) {
28402
														custumFunc = data_.FunctionCode;
28403
													}
28404
												}
28405
											});
28406
										}
28407
											//SASWANTO 6JULI2022 End
28408
										if (custumFunc) {
28409
											eval(custumFunc)
28410
										}												
28411
                                        if (index != -1) {
28412
                                            var rc = store.getAt(index);
28413
                                            val = rc.get(displayValue);
28414
                                        } else {
28415
                                            val = value;
28416
                                        }
28417
                                        return val;
28418
                                    },
28419
                                    filter: {
28420
                                        type: 'list',
28421
                                        itemDefaults: {
28422
                                            emptyText: 'Search for...'
28423
                                        }
28424
                                    }
28425
                                });
28426
                            } else if (rec.SearchType == '5') {
28427
                                var valueField = null;
28428
                                var displayValue = null;
28429
                                var AdditionaldisplayValue = null;
28430
                                var TableRef = undefined;
28431
                                if (rec.TableRef != '') {
28432
                                    TableRef = rec.TableRef;
28433
                                    Ext.Ajax.request({
28434
                                        async: false,
28435
                                        method: 'POST',
28436
                                        url: '/UserControl/GetStore',
28437
                                        params: {
28438
                                            tableName: 'SDATATABLEFIELD',
28439
                                            param: 'TableName[equal]' + rec.TableRef
28440
                                        },
28441
                                        success: function (response) {
28442
                                            var results = Ext.decode(response.responseText);
28443
                                            data_ = results.data;
28444
                                            if (data_ != undefined) {
28445
                                                valueField_ = $.grep(data_, function (r) {
28446
                                                    return r.ValueField == '1'
28447
                                                });
28448
                                                if (valueField_.length > 0) {
28449
                                                    valueField = valueField_[0].FieldName
28450
                                                }
28451

    
28452
                                                displayValue_ = $.grep(data_, function (r) {
28453
                                                    return r.DisplayValue == '1' || r.DisplayValue == '2'
28454
                                                });
28455
                                                if (displayValue_.length > 0) {
28456
                                                    displayValue = displayValue_[0].FieldName;
28457
                                                }
28458
                                                if (displayValue_.length >= 2) {
28459
                                                    AdditionaldisplayValue = displayValue_[1].FieldName
28460
                                                }
28461
                                            }
28462
                                        }
28463
                                    });
28464
                                }
28465
                                Ext.create('Ext.data.Store', {
28466
                                    storeId: 'store_' + me.tableName + rec.FieldName,
28467
                                    autoLoad: true,
28468
                                    proxy: {
28469
                                        method: 'POST',
28470
                                        type: 'ajax',
28471
                                        url: '/UserControl/GetStoreAuth',
28472
                                        extraParams: {
28473
                                            tableName: TableRef,
28474
                                            param: rec.ParamCombo,
28475
                                            menuId: MinovaUtil.GetMenuID()
28476
                                        },
28477
                                        reader: {
28478
                                            type: 'json',
28479
                                            root: 'data',
28480
                                            totalProperty: 'data[0].TotalCount'
28481
                                        }
28482
                                    }
28483
                                });
28484
                                cols.push({
28485
                                    //xtype : 'minovacombocolumn',
28486
                                    hidden: Hidden_,
28487
                                    text: rec.HeaderTitle,
28488
                                    dataIndex: rec.FieldName,
28489
                                    //valueField : valueField,
28490
                                    //displayField : displayValue,
28491
                                    //store : 'store_' + me.tableName + rec.FieldName,
28492
                                    tpl: Ext.create('Ext.XTemplate',
28493
                                        '<ul class="x-list-plain"><tpl for=".">',
28494
                                        '<li role="option" class="x-boundlist-item">{' + AdditionaldisplayValue + '} - {' + displayValue + '}</li>',
28495
                                        '</tpl></ul>'),
28496
                                    displayTpl: Ext.create('Ext.XTemplate',
28497
                                        '<tpl for=".">',
28498
                                        '{' + AdditionaldisplayValue + '} - {' + displayValue + '}',
28499
                                        '</tpl>'),
28500
                                    editor: {
28501
                                        allowBlank: null_,
28502
                                        xtype: 'combobox',
28503
                                        readOnly: ReadOnly_,
28504
                                        id: rec.TableName + rec.FieldName,
28505
                                        nameTable: rec.TableName,
28506
                                        fieldGrid: rec.FieldName,
28507
                                        valueField: valueField,
28508
                                        displayField: displayValue,
28509
                                        store: 'store_' + me.tableName + rec.FieldName,
28510
                                        value: rec.DefaultValue,
28511
                                        tpl: Ext.create('Ext.XTemplate',
28512
                                            '<ul class="x-list-plain"><tpl for=".">',
28513
                                            '<li role="option" class="x-boundlist-item">{' + AdditionaldisplayValue + '} - {' + displayValue + '}</li>',
28514
                                            '</tpl></ul>'),
28515
                                        displayTpl: Ext.create('Ext.XTemplate',
28516
                                            '<tpl for=".">',
28517
                                            '{' + AdditionaldisplayValue + '} - {' + displayValue + '}',
28518
                                            '</tpl>')
28519
                                    },
28520
                                    renderer: function (value) {
28521
                                        var store = Ext.data.StoreManager.lookup('store_' + me.tableName + rec.FieldName);
28522
                                        var index = store.find(valueField, value);
28523
                                        var val = "";
28524
                                        if (index != -1) {
28525
                                            var rc = store.getAt(index);
28526
                                            //val = rc.get(displayValue);
28527
                                            val = rc.get(AdditionaldisplayValue) + ' - ' + rc.get(displayValue);
28528
                                        } else {
28529
                                            val = value;
28530
                                        }
28531
                                        return val;
28532
                                    },
28533
                                    filter: {
28534
                                        type: 'list',
28535
                                        itemDefaults: {
28536
                                            emptyText: 'Search for...'
28537
                                        }
28538
                                    }
28539
                                });
28540
                            } else if (rec.SearchType == '2') {
28541
                                var triger = (rec.TriggerCombo).split('$');
28542
                                var targetField_ = triger[0];
28543
                                var fieldValue_ = triger[1];
28544
                                cols.push({
28545
                                    text: rec.HeaderTitle,
28546
                                    hidden: Hidden_,
28547
                                    dataIndex: rec.FieldName,
28548
                                    filter: {
28549
                                        itemDefaults: {
28550
                                            emptyText: 'Search for...'
28551
                                        }
28552
                                    },
28553
                                    editor: {
28554
                                        allowBlank: null_,
28555
                                        xtype: 'minovalookupgrid',
28556
                                        readOnly: ReadOnly_,
28557
                                        isGrid: true,
28558
                                        fieldTarget: targetField_,
28559
                                        fieldValue: fieldValue_,
28560
                                        isGrid: true,
28561
                                        id: tableName + rec.FieldName,
28562
                                        tableName: rec.TableRef,
28563
                                        triggerCls: 'x-form-search-trigger',
28564
                                        vtype: 'alphanum',
28565
                                        nameTable: rec.TableName,
28566
                                        fieldGrid: rec.FieldName,
28567
                                        listeners: {
28568
                                            change: function (val) {
28569
                                                var custumFunc = rec.SelectFunction;
28570
                                                if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
28571
                                                    Ext.Ajax.request({
28572
                                                        async: false,
28573
                                                        method: 'POST',
28574
                                                        url: '/UserControl/GetStore',
28575
                                                        params: {
28576
                                                            tableName: 'PCMFUNC',
28577
                                                            param: 'FuncName[equal]' + rec.custumFunc + ',Active[=]1'
28578
                                                        },
28579
                                                        success: function (response) {
28580
                                                            var results = Ext.decode(response.responseText);
28581
                                                            data_ = results.data[0];
28582
                                                            if (data_ != undefined) {
28583
                                                                custumFunc = data_.FunctionCode;
28584
                                                            }
28585
                                                        }
28586
                                                    });
28587
                                                }
28588
                                                if (custumFunc) {
28589
                                                    eval(custumFunc)
28590
                                                }
28591
                                            }
28592
                                        }
28593
                                    }
28594
                                });
28595
                            } else if (rec.SearchType == '3') {
28596
                                cols.push({
28597
                                    text: rec.HeaderTitle,
28598
                                    hidden: Hidden_,
28599
                                    dataIndex: rec.FieldName,
28600
                                    filter: {
28601
                                        itemDefaults: {
28602
                                            emptyText: 'Search for...'
28603
                                        }
28604
                                    },
28605
                                    editor: {
28606
                                        allowBlank: null_,
28607
                                        xtype: 'MinovaLookupTree',
28608
                                        readOnly: ReadOnly_,
28609
                                        id: tableName + rec.FieldName,
28610
                                        tableName: rec.TableRef,
28611
                                        triggerCls: 'x-form-search-trigger',
28612
                                        vtype: 'alphanum',
28613
                                        treeSructure: rec.SearchFunction,
28614
                                        objClassValue: rec.ParamCombo,
28615
                                        nameTable: rec.TableName,
28616
                                        fieldGrid: rec.FieldName,
28617
                                        listeners: {
28618
                                            change: function (val) {
28619
                                                var custumFunc = rec.SelectFunction;
28620
                                                if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
28621
                                                    Ext.Ajax.request({
28622
                                                        async: false,
28623
                                                        method: 'POST',
28624
                                                        url: '/UserControl/GetStore',
28625
                                                        params: {
28626
                                                            tableName: 'PCMFUNC',
28627
                                                            param: 'FuncName[equal]' + rec.custumFunc + ',Active[=]1'
28628
                                                        },
28629
                                                        success: function (response) {
28630
                                                            var results = Ext.decode(response.responseText);
28631
                                                            data_ = results.data[0];
28632
                                                            if (data_ != undefined) {
28633
                                                                custumFunc = data_.FunctionCode;
28634
                                                            }
28635
                                                        }
28636
                                                    });
28637
                                                }
28638
                                                if (custumFunc) {
28639
                                                    eval(custumFunc)
28640
                                                }
28641
                                            }
28642
                                        }
28643
                                    }
28644
                                });
28645
                            } else if (rec.SearchType != '0' && rec.SearchType != '1' && rec.SearchType != '3' && (rec.FieldName == 'EmployeeID' || rec.FieldName == 'ApplicantID' || rec.FieldName == 'EmployeeIDFrom' || rec.FieldName == 'EmployeeIDTo') && isLookup != true) {
28646
                                var triger = (rec.TriggerCombo).split('&');
28647
                                var targetField_ = triger[0];
28648
                                var fieldValue_ = triger[0];
28649
                                cols.push({
28650
                                    text: rec.HeaderTitle,
28651
                                    hidden: Hidden_,
28652
                                    dataIndex: rec.FieldName,
28653
                                    filter: {
28654
                                        itemDefaults: {
28655
                                            emptyText: 'Search for...'
28656
                                        }
28657
                                    },
28658
                                    editor: {
28659
                                        allowBlank: null_,
28660
                                        xtype: 'lookupemployee',
28661
                                        readOnly: ReadOnly_,
28662
                                        isGrid: true,
28663
                                        fieldTarget: targetField_,
28664
                                        fieldValue: fieldValue_,
28665
                                        isGrid: true,
28666
                                        id: tableName + rec.FieldName,
28667
                                        tableName: rec.TableRef, //name tabel yang jadi ref-nya
28668
                                        triggerCls: 'x-form-search-trigger',
28669
                                        vtype: 'alphanum', // disable space
28670
                                        nameTable: rec.TableName,
28671
                                        fieldGrid: rec.FieldName,
28672
                                        listeners: {
28673
                                            change: function (val) {
28674
                                                var custumFunc = rec.SelectFunction;
28675
                                                if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
28676
                                                    Ext.Ajax.request({
28677
                                                        async: false,
28678
                                                        method: 'POST',
28679
                                                        url: '/UserControl/GetStore',
28680
                                                        params: {
28681
                                                            tableName: 'PCMFUNC',
28682
                                                            param: 'FuncName[equal]' + rec.custumFunc + ',Active[=]1'
28683
                                                        },
28684
                                                        success: function (response) {
28685
                                                            var results = Ext.decode(response.responseText);
28686
                                                            data_ = results.data[0];
28687
                                                            if (data_ != undefined) {
28688
                                                                custumFunc = data_.FunctionCode;
28689
                                                            }
28690
                                                        }
28691
                                                    });
28692
                                                }
28693
                                                if (custumFunc) {
28694
                                                    eval(custumFunc)
28695
                                                }
28696
                                            }
28697
                                        }
28698
                                    }
28699
                                });
28700
                            } else if (rec.SearchType == '4' && isLookup != true) {
28701
                                cols.push({
28702
                                    text: rec.HeaderTitle,
28703
                                    hidden: Hidden_,
28704
                                    dataIndex: rec.FieldName,
28705
                                    filter: {
28706
                                        itemDefaults: {
28707
                                            emptyText: 'Search for...'
28708
                                        }
28709
                                    },
28710
                                    editor: {
28711
                                        allowBlank: null_,
28712
                                        xtype: 'lookupemployee',
28713
                                        readOnly: ReadOnly_,
28714
                                        isGrid: true,
28715
                                        fieldTarget: targetField_,
28716
                                        fieldValue: fieldValue_,
28717
                                        isGrid: true,
28718
                                        id: tableName + rec.FieldName,
28719
                                        tableName: rec.TableRef, //name tabel yang jadi ref-nya
28720
                                        triggerCls: 'x-form-search-trigger',
28721
                                        vtype: 'alphanum', // disable space
28722
                                        nameTable: rec.TableName,
28723
                                        fieldGrid: rec.FieldName,
28724
                                        listeners: {
28725
                                            change: function (val) {
28726
                                                var custumFunc = rec.SelectFunction;
28727
                                                if (custumFunc.toLowerCase().substring(0, 2) == 'fn') {
28728
                                                    Ext.Ajax.request({
28729
                                                        async: false,
28730
                                                        method: 'POST',
28731
                                                        url: '/UserControl/GetStore',
28732
                                                        params: {
28733
                                                            tableName: 'PCMFUNC',
28734
                                                            param: 'FuncName[equal]' + rec.custumFunc + ',Active[=]1'
28735
                                                        },
28736
                                                        success: function (response) {
28737
                                                            var results = Ext.decode(response.responseText);
28738
                                                            data_ = results.data[0];
28739
                                                            if (data_ != undefined) {
28740
                                                                custumFunc = data_.FunctionCode;
28741
                                                            }
28742
                                                        }
28743
                                                    });
28744
                                                }
28745
                                                if (custumFunc) {
28746
                                                    eval(custumFunc)
28747
                                                }
28748
                                            }
28749
                                        }
28750
                                    }
28751
                                });
28752
                            } else if (rec.FixedValue != '') { // add by taufan
28753
                                cols.push({
28754
                                    text: rec.HeaderTitle,
28755
                                    hidden: Hidden_,
28756
                                    dataIndex: rec.FieldName,
28757
                                    filter: {
28758
                                        itemDefaults: {
28759
                                            emptyText: 'Search for...'
28760
                                        }
28761
                                    },
28762
                                    editor: {
28763
                                        allowBlank: null_,
28764
                                        xtype: 'minovafixvalue',
28765
                                        readOnly: ReadOnly_,
28766
                                        id: rec.TableName + rec.FieldName,
28767
                                        name: rec.TableName + rec.FieldName,
28768
                                        nameTable: rec.TableName,
28769
                                        fieldGrid: rec.FieldName,
28770
                                        fixedValue: rec.FixedValue,
28771
                                        valueField: 'code',
28772
                                        displayField: 'desc',
28773
                                        value: rec.DefaultValue
28774
                                    },
28775
                                    renderer: function (value) {
28776
                                        var val = "";
28777
                                        var storeData = [];
28778
                                        var str = rec.FixedValue;
28779
                                        var hasil = str.split('||');
28780
                                        hasil.forEach(function (h) {
28781
                                            store_ = h.split('=')
28782
                                            storeData.push({
28783
                                                code: store_[0],
28784
                                                desc: store_[1]
28785
                                            });
28786
                                        });
28787
                                        var item = storeData.find(x => x.code == value);
28788
                                        if (item != undefined) {
28789
                                            val = item.desc;
28790
                                        }
28791
                                        return val;
28792
                                    }
28793
                                });
28794
                            } else {
28795
                                var _custumFunc = null;
28796
                                Ext.Ajax.request({
28797
                                    async: false,
28798
                                    method: 'POST',
28799
                                    url: '/UserControl/GetStore',
28800
                                    params: {
28801
                                        tableName: 'SDATATABLEFIELD',
28802
                                        param: 'FieldName[equal]' + rec.FieldName + ',TableName[equal]' + me.tableName
28803
                                    },
28804
                                    success: function (response) {
28805
                                        var results = Ext.decode(response.responseText);
28806
                                        data_ = results.data[0];
28807
                                        if (data_ != undefined) {
28808
                                            _custumFunc = data_.SelectFunction;
28809
                                        }
28810
                                    }
28811
                                });
28812
                                _xtype = 'textfield';
28813
                                if (rec.Length > 250) {
28814
                                    _xtype = 'textareafield';
28815
                                    cols.push({
28816
                                        text: rec.HeaderTitle,
28817
                                        xtype: 'gridcolumn',
28818
                                        hidden: Hidden_,
28819
                                        dataIndex: rec.FieldName,
28820
                                        filter: {
28821
                                            itemDefaults: {
28822
                                                emptyText: 'Search for...'
28823
                                            }
28824
                                        },
28825
                                        cellWrap: true,
28826
                                        width: (rec.Length * 6.5 + 20) > 300 ? 300 : rec.Length * 6.5 + 30,
28827
                                        editor: {
28828
                                            allowBlank: null_,
28829
                                            xtype: _xtype,
28830
                                            readOnly: ReadOnly_,
28831
                                            id: tableName + rec.FieldName,
28832
                                            nameTable: rec.TableName,
28833
                                            fieldGrid: rec.FieldName,
28834
                                            value: rec.DefaultValue,
28835
                                            maxLength: rec.Length,
28836
                                            grow: true,
28837
                                            listeners: {
28838
                                                //initialize: function (editor) {
28839
                                                //    editor.ownerCt.alignTo(editor.ownerCt.boundEl, 'tl-tl');
28840
                                                //    editor.ownerCt.alignment = 'tl-tl';
28841
                                                //},
28842
                                                afterrender: function () {
28843
                                                    var me = this;
28844
                                                    //me.el.swallowEvent(['keypress', 'keydown']);
28845
                                                }
28846
                                            }
28847
                                        },
28848
                                        renderer: function (v) {
28849
                                            result = v.replace(/\r\n\r\n/g, "</p><p>").replace(/\n\n/g, "</p><p>");
28850
                                            result = result.replace(/\r\n/g, "<br />").replace(/\n/g, "<br />");
28851
                                            result = result.replace(/\r\t/g, "&emsp;").replace(/\t/g, "&emsp;");
28852
                                            return result;
28853
                                        }
28854
                                    });
28855
                                }
28856
                                else {
28857
                                    cols.push({
28858
                                        text: rec.HeaderTitle,
28859
                                        xtype: 'gridcolumn',
28860
                                        hidden: Hidden_,
28861
                                        dataIndex: rec.FieldName,
28862
                                        filter: {
28863
                                            itemDefaults: {
28864
                                                emptyText: 'Search for...'
28865
                                            }
28866
                                        },
28867
                                        cellWrap: true,
28868
                                        width: (rec.Length * 6.5 + 20) > 300 ? 300 : rec.Length * 6.5 + 30,
28869
                                        editor: {
28870
                                            allowBlank: null_,
28871
                                            xtype: _xtype,
28872
                                            readOnly: ReadOnly_,
28873
                                            id: tableName + rec.FieldName,
28874
                                            nameTable: rec.TableName,
28875
                                            fieldGrid: rec.FieldName,
28876
                                            value: rec.DefaultValue,
28877
                                            maxLength: rec.Length,
28878
                                            grow: true,
28879
                                            listeners: {
28880
                                                change: function (val) {
28881
                                                    if (_custumFunc) {
28882
                                                        eval(_custumFunc)
28883
                                                    }
28884
                                                }
28885
                                                /*change: function (val) {
28886
                                                    var custumFunc = null;
28887
                                                    Ext.Ajax.request({
28888
                                                        async: false,
28889
                                                        method: 'POST',
28890
                                                        url: '/UserControl/GetStore',
28891
                                                        params: {
28892
                                                            tableName: 'SDATATABLEFIELD',
28893
                                                            param: 'FieldName[equal]' + rec.FieldName + ',TableName[equal]' + me.tableName
28894
                                                        },
28895
                                                        success: function (response) {
28896
                                                            var results = Ext.decode(response.responseText);
28897
                                                            data_ = results.data[0];
28898
                                                            if (data_ != undefined) {
28899
                                                                custumFunc = data_.SelectFunction;
28900
                                                                //console.log(data_)
28901
                                                            }
28902
                                                        }
28903
                                                    });
28904
    
28905
                                                    if (custumFunc) {
28906
                                                        eval(custumFunc)
28907
                                                    }
28908
                                                } */
28909
                                            }
28910
                                        }
28911
                                    });
28912
                                }
28913
                            }
28914
                            break
28915
                    }
28916
                } else {
28917
                    cols.push({
28918
                        text: rec.HeaderTitle,
28919
                        hidden: Hidden_,
28920
                        dataIndex: rec.FieldName,
28921
                        hidden: true,
28922
                        editor: {
28923
                            allowBlank: true,
28924
                            xtype: 'textfield',
28925
                            readOnly: ReadOnly_,
28926
                            id: tableName + rec.FieldName,
28927
                            nameTable: rec.TableName,
28928
                            fieldGrid: rec.FieldName,
28929
                            value: rec.DefaultValue
28930
                        },
28931
                        filter: {
28932
                            itemDefaults: {
28933
                                emptyText: 'Search for...'
28934
                            }
28935
                        }
28936
                    });
28937
                }
28938
            });
28939

    
28940
        };        
28941
        //cols.push({
28942
        //    xtype: 'actioncolumn',
28943
        //    text: 'Edit',
28944
        //    maxWidth: 150,
28945
        //    minWidth: 50,
28946
        //    border: false,
28947
        //    itemId: 'startEditActionColumn',
28948
        //    align: 'center',
28949
        //    items: [
28950
        //        {
28951
        //            iconCls: 'x-fa fa-pencil-square-o',
28952
        //            handler: function (grid, rowIndex, colIndex) {
28953
        //                grid.editingPlugin.startEdit(rowIndex, 0);
28954
        //            }
28955
        //        }
28956
        //    ]
28957
        //});
28958
        addData = addData + "}";
28959
        Ext.applyIf(me, {
28960
            items: [{
28961
                xtype: 'grid',
28962
                id: gridName,
28963
                name: gridName,
28964
                height: height,
28965
                minHeight: me.minHeight,
28966
                maxHeight: me.maxHeight,
28967
                addFlag: true,
28968
                deleteFlag: true,
28969
                store: Ext.create('Ext.data.Store', {
28970
                    storeId: storeID,
28971
                    fields: fieldStore,
28972
                    //groupField: 'QuestionGroup',
28973
                    grouper: {
28974
                        sortProperty: 'SeqQuest',
28975
                        groupFn: function (record) {
28976
                            return record.get('QuestionGroup');
28977
                        }
28978
                    },
28979
                    proxy: {
28980
                        method: 'POST',
28981
                        type: 'ajax',
28982
                        url: '',
28983
                        reader: {
28984
                            type: 'json',
28985
                            root: 'data'
28986
                        }
28987
                    }
28988
                }),
28989
                dockedItems: [{
28990
                    xtype: 'toolbar',
28991
                    items: [{
28992
                        text: 'Add',
28993
                        hidden: hide_,
28994
                        name: tableName + 'Add',
28995
                        iconCls: 'fa-plus-circle',
28996
                        style: 'font-family: FontAwesome',
28997
                        handler: function () {
28998
                            var grid = Ext.getCmp(gridName);
28999
                            if (grid.addFlag === true) {
29000
                                var store = Ext.StoreMgr.lookup(storeID)
29001
                                idx = store.getCount();
29002
                                var action = getParam('action');
29003
                                var data = '';
29004
                                var Sequence = 0;
29005
                                if (idx == 0) {
29006
                                    Sequence = 1;
29007
                                } else {
29008
                                    Sequence = 1 + idx;
29009
                                }
29010
                                var seq = 'Sequence';
29011
                                var SequenceValue = Sequence;
29012
                                eval(addData);
29013
                                data[seq] = SequenceValue;
29014
                                store.insert(idx, data);
29015
                            }
29016
                        }
29017
                    }, {
29018
                        text: 'Delete',
29019
                        hidden: hide_,
29020
                        name: tableName + 'DeleteText',
29021
                        iconCls: 'fa-trash-o',
29022
                        style: 'font-family: FontAwesome',
29023
                        handler: function () {
29024
                            var grid = Ext.getCmp(gridName);
29025
                            if (grid.deleteFlag === true) {
29026
                                var me = this,
29027
                                    store = Ext.StoreMgr.lookup(storeID)
29028
                                var grid = Ext.getCmp(gridName);
29029
                                Ext.MessageBox.show({
29030
                                    title: 'Remove tab',
29031
                                    msg: "This will remove. Do you want to continue?",
29032
                                    buttons: Ext.MessageBox.YESNO,
29033
                                    fn: function (choice) {
29034
                                        console.log(choice);
29035
                                        if (choice === 'yes') {
29036
                                            var selection = grid.getView().getSelectionModel().getSelection()[0];
29037
                                            if (selection) {
29038
                                                store.remove(selection);
29039
                                            }
29040
                                        }
29041
                                    }
29042
                                });
29043
                            }
29044
                        }
29045
                        },
29046
                        {
29047
                            xtype: 'label',
29048
                            name: tableName + 'Label',
29049
							id: tableName + 'Label', //YN 220316
29050
							hidden: true, //YN 220316
29051
                            html: '<i>*Please double click on the cell/row to edit content.</i>'
29052
                        }]
29053
                }
29054
                ],
29055
                columns: {
29056
                    defaults: {
29057
                        menuDisabled: true
29058
                    },
29059
                    items: cols
29060
                },
29061
                //selModel: 'rowmodel',
29062
                selType: 'rowmodel', //checkSelection,
29063
                plugins: [
29064
                    Ext.create('Ext.grid.plugin.CellEditing', {
29065
                        clicksToEdit: 2
29066
                    })
29067
                ],
29068
                //plugins: {
29069
                //    //ptype: 'actionColumnRowEditing', //rowediting
29070
                //    //pluginId: 'rowEditing',
29071
                //    ptype: 'cellediting',
29072
                //    //hiddenColumnsOnEdit: ['startEditActionColumn'],
29073
                //    clicksToEdit: 2,
29074
                //    //saveButtonIconCls: 'x-fa fa-floppy-o',
29075
                //    listeners: {}
29076
                //},
29077
                //listeners: {
29078
                //    'beforeedit': function (editor) {
29079
                //        editor.getEditor().floatingButtons.items.items[0].hide();
29080
                //        editor.getEditor().floatingButtons.items.items[1].hide();
29081
                //    }
29082
                //},
29083
                features: features,
29084
                viewConfig: {
29085
                    listeners: {
29086
                        refresh: function (dataview) {
29087
                            Ext.each(dataview.panel.columns, function (column) {
29088
                                column.autoSize();
29089
                                column.setWidth(column.width + 20); //YN 220316
29090
                            })
29091
                        }
29092
                    }
29093
                }
29094
            }
29095
            ]
29096
        });
29097
        me.callParent(arguments);
29098
    }
29099
});
29100

    
29101
/*Grid Display ESS Generator YN 20211216 */
29102
Ext.define('MinovaUtil.MinovaES.MinovaGridDisplay', {
29103
    extend: 'Ext.grid.Panel',
29104
    requires: ['Ext.grid.RowNumberer'],
29105
    alias: 'widget.minovagriddisplay',
29106
    //alternateClassName : 'Ext.grid.MinovaGrid',
29107
    tableName: undefined,
29108
    isLookup: undefined,
29109
    param: undefined,
29110
    pagesize: undefined,
29111
    storeName: undefined,
29112
    layoutType: undefined,
29113
    enableLocking: true,
29114
    initComponent: function () {
29115
        var me = this;
29116
        var cols_ = [];
29117
        var fieldeditor = {};
29118
        var hasil = null;
29119
        var autoLoad = true;
29120
        var LangID = MinovaUtil.GetLangID();
29121
        parameter = null;
29122
        if (me.isLookup == true || isLookup == 1 || isLookup == 'Y') {
29123
            parameter = "LangID='" + LangID + "',TableName='" + me.tableName + "',LookupGrid='1'"
29124
        } else {
29125
            parameter = "LangID='" + LangID + "',TableName='" + me.tableName + "'"
29126
        }
29127
        Ext.Ajax.request({
29128
            async: false,
29129
            method: 'POST',
29130
            url: '/UserControl/GetStore',
29131
            params: {
29132
                tableName: 'PDSBS0007',
29133
                param: parameter
29134
            },
29135
            success: function (response) {
29136
                var results = Ext.decode(response.responseText);
29137
                hasil = results.data;
29138
            }
29139
        });
29140
        if (hasil.length > 0) {
29141
            Ext.each(hasil, function (rec) {
29142
                var null_ = null;
29143
                if (rec.IsPrimaryKey == true) {
29144
                    null_ = false;
29145
                }
29146
                if (rec.IsRequired == true) {
29147
                    null_ = false;
29148
                } else {
29149
                    null_ = true;
29150
                }
29151
                if (rec.GridView == 1) {
29152
                    switch (rec.FormatRef) {
29153
                        case "date":
29154
                            cols_.push({
29155
                                xtype: 'minovadatecolumn',
29156
                                text: rec.HeaderTitle,
29157
                                dataIndex: rec.FieldName,
29158
                                width: 100,
29159
                                filter: {
29160
                                    type: 'date',
29161
                                    itemDefaults: {
29162
                                        emptyText: 'Search for...'
29163
                                    }
29164
                                }
29165
                            });
29166
                            break
29167
                        case "amountencrypt":
29168
                            cols_.push({
29169
                                xtype: 'minovaamountcolumn',
29170
                                text: rec.HeaderTitle,
29171
                                dataIndex: rec.FieldName,
29172
                                align: 'right',
29173
                                width: 100,
29174
                                filter: {
29175
                                    type: 'string',
29176
                                    itemDefaults: {
29177
                                        emptyText: 'Search for...'
29178
                                    }
29179
                                }
29180
                            });
29181
                            break
29182
                        case "amount":
29183
                            cols_.push({
29184
                                xtype: 'minovacurrancycolumn',
29185
                                text: rec.HeaderTitle,
29186
                                dataIndex: rec.FieldName,
29187
                                align: 'right',
29188
                                width: 100,
29189
                                filter: {
29190
                                    type: 'number',
29191
                                    itemDefaults: {
29192
                                        emptyText: 'Search for...'
29193
                                    }
29194
                                }
29195
                            });
29196
                            break
29197
                        case "datetime":
29198
                            cols_.push({
29199
                                xtype: 'minovadatetimecolumn',
29200
                                text: rec.HeaderTitle,
29201
                                dataIndex: rec.FieldName,
29202
                                width: 140,
29203
                                filter: {
29204
                                    type: 'string',
29205
                                    itemDefaults: {
29206
                                        emptyText: 'Search for...'
29207
                                    }
29208
                                }
29209
                            });
29210
                            break
29211
                        default:
29212
                            if (rec.DataRef == 'CREATEBY' || rec.DataRef == 'CHANGEBY') {
29213
                                cols_.push({
29214
                                    text: rec.HeaderTitle,
29215
                                    dataIndex: rec.FieldName,
29216
                                    width: 100,
29217
                                    filter: {
29218
                                        type: 'string',
29219
                                        itemDefaults: {
29220
                                            emptyText: 'Search for...'
29221
                                        }
29222
                                    }
29223
                                });
29224
                            } else if (rec.SearchType == '2') {
29225
                                cols_.push({
29226
                                    xtype: 'minovalookupcolumn',
29227
                                    text: rec.HeaderTitle,
29228
                                    tableName: rec.TableRef,
29229
                                    dataIndex: rec.FieldName,
29230
                                    filter: {
29231
                                        itemDefaults: {
29232
                                            emptyText: 'Search for...'
29233
                                        }
29234
                                    }
29235
                                });
29236
                            } else if (rec.TableRef != "") {
29237
                                if (rec.TableRef != null) {
29238
                                    var valueField = null;
29239
                                    Ext.Ajax.request({
29240
                                        async: false,
29241
                                        method: 'POST',
29242
                                        url: '/UserControl/GetStore',
29243
                                        params: {
29244
                                            tableName: 'SDATATABLEFIELD',
29245
                                            param: 'ValueField[equal]1,TableName[equal]' + rec.TableRef
29246
                                        },
29247
                                        success: function (response) {
29248
                                            var results = Ext.decode(response.responseText);
29249
                                            data_ = results.data[0];
29250
                                            if (data_ != undefined) {
29251
                                                valueField = data_.FieldName;
29252
                                            }
29253
                                        }
29254
                                    });
29255

    
29256
                                    displayValue = null;
29257
                                    Ext.Ajax.request({
29258
                                        async: false,
29259
                                        method: 'POST',
29260
                                        url: '/UserControl/GetStore',
29261
                                        params: {
29262
                                            tableName: 'SDATATABLEFIELD',
29263
                                            param: 'DisplayValue[equal]1,TableName[equal]' + rec.TableRef
29264
                                        },
29265
                                        success: function (response) {
29266
                                            var results = Ext.decode(response.responseText);
29267
                                            data_ = results.data[0];
29268
                                            if (data_ != undefined) {
29269
                                                displayValue = data_.FieldName;
29270
                                                //console.log(data_)
29271
                                            }
29272
                                        }
29273
                                    });
29274
                                    var store_ = Ext.StoreMgr.lookup('store_' + rec.FieldName);
29275
                                    var count_ = 0;
29276
                                    if (store_) {
29277
                                        count_ = store_.count();
29278
                                    }
29279
                                    if (count_ == 0) {
29280
                                        Ext.create('Ext.data.Store', {
29281
                                            storeId: 'store_' + rec.FieldName,
29282
                                            autoLoad: true,
29283
                                            proxy: {
29284
                                                method: 'POST',
29285
                                                type: 'ajax',
29286
                                                url: '/UserControl/GetStore',
29287
                                                extraParams: {
29288
                                                    tableName: rec.TableRef,
29289
                                                    param: rec.ParamCombo
29290
                                                },
29291
                                                reader: {
29292
                                                    type: 'json',
29293
                                                    root: 'data',
29294
                                                    totalProperty: 'data[0].TotalCount'
29295
                                                }
29296
                                            }
29297
                                        })
29298
                                    }
29299
                                    cols_.push({
29300
                                        xtype: 'minovacombocolumn',
29301
                                        text: rec.HeaderTitle,
29302
                                        dataIndex: rec.FieldName,
29303
                                        valueField: valueField,
29304
                                        displayField: displayValue,
29305
                                        store: 'store_' + rec.FieldName,
29306
                                        filter: {
29307
                                            type: 'list',
29308
                                            itemDefaults: {
29309
                                                emptyText: 'Search for...'
29310
                                            }
29311
                                        }
29312
                                    });
29313
                                }
29314

    
29315
                            } else {
29316
                                cols_.push({
29317
                                    text: rec.HeaderTitle,
29318
                                    dataIndex: rec.FieldName,
29319
                                    width: rec.Length * 6.5 + 20, //(rec.Length * 6.5 + 20) > 300 ? 300 : rec.Length * 6.5 + 30,
29320
                                    flex: ((rec.Length * 6.5 + 20) >= 800)?1:0,
29321
                                    //autoSizeColumn: true,
29322
                                    cellWrap: true,
29323
                                    hidden: (rec.IsHidden=='1')? true:false,
29324
                                    filter: {
29325
                                        itemDefaults: {
29326
                                            emptyText: 'Search for...'
29327
                                        }
29328
                                    }
29329
                                });
29330
                            }
29331
                            break
29332
                    }
29333
                }
29334
                else {
29335
                    cols_.push({
29336
                        text: rec.HeaderTitle,
29337
                        dataIndex: rec.FieldName,
29338
                        hidden: true,
29339
                        filter: {
29340
                            itemDefaults: {
29341
                                emptyText: 'Search for...'
29342
                            }
29343
                        }
29344
                    });
29345
                }
29346
            });
29347
        };
29348
        var param_ = me.param;
29349
        if (param_ == undefined) {
29350
            param_ = ''
29351
        }
29352

    
29353
        var jsStoreGrid = new Ext.create('Ext.data.Store', {
29354
            storeId: me.storeName,
29355
            autoLoad: false,
29356
            proxy: {
29357
                method: 'POST',
29358
                type: 'ajax',
29359
                url: '/UserControl/GetStore',
29360
                extraParams: {
29361
                    tableName: me.tableName,
29362
                    param: param_
29363
                },
29364
                reader: {
29365
                    type: 'json',
29366
                    root: 'data',
29367
                    totalProperty: 'data[0].TotalCount'
29368
                }
29369
            }
29370
        });
29371

    
29372
        Ext.applyIf(me, {
29373
            defaults: {
29374
                autoSizeColumn: true,
29375
            },
29376
            columns: cols_,
29377
            store: jsStoreGrid,
29378
            viewConfig: {
29379
                listeners: {
29380
                    refresh: function (dataview) {
29381
                        Ext.each(dataview.panel.columns, function (column) {
29382
                            if (column.autoSizeColumn === true)
29383
                                column.autoSize();
29384
                        })
29385
                    }
29386
                }
29387
            },
29388
        });
29389
        me.callParent(arguments);
29390
    }
29391

    
29392
});
29393

    
29394
/*https://fiddle.sencha.com/#fiddle/1544&view/editor */
29395
Ext.define('MinovaUtil.MinovaES.StoreCheckboxGroup', {
29396
    extend: 'Ext.form.CheckboxGroup',
29397
    xtype: 'storecheckboxgroup', // <- this "xtype" is a unique name of the component.
29398
    name: undefined,
29399
    nametxt: undefined,
29400
    formname: undefined,
29401
    nameTable: undefined,
29402
    initComponent: function () {
29403
        var me = this;
29404
        if (!me.store) throw "No store defined for StoreCheckboxGroup";
29405
        if (!me.mapFn) throw "No mapFn defined for StoreCheckboxGroup";
29406
        if (me.items) throw "Items may not be defined for StoreCheckboxGroup; we get them from the store!";
29407
        var checklistStore = me.store, // <-- using the required "store" property
29408
            renderCheckboxes = function () {
29409
                me.removeAll();
29410
                //me.add(formfield = new Ext.form.TextField({
29411
                //    name: me.nametxt,
29412
                //    formname: me.formname,
29413
                //    nameTable: me.nameTable,
29414
                //}));
29415
                me.add(
29416
                    checklistStore.getRange().map(me.mapFn)); // <-- using the required "mapFn" property
29417
            };
29418
        me.callParent(arguments);
29419
        renderCheckboxes(); // <-- using the function I defined above
29420
        checklistStore.on({
29421
            load: renderCheckboxes, // <-------- binding the
29422
            update: renderCheckboxes, // <------ function to
29423
            datachanged: renderCheckboxes, // <- the store
29424
            filterchange: renderCheckboxes // <- events
29425
        });
29426
    }
29427
});
29428
/* END YN 20211216 */
(21-21/21)